jung 0.6.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,10 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/
+.sass-cache/
+.DS_Store
+._*
+Gemfile.lock
+.AppleDouble
+test/config/*.yml

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "gibbon"
+gem "activesupport"
+gem "i18n"
+gem "rdoc"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem "pry"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Ariel Patschiki
+
+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.rdoc

@@ -0,0 +1,11 @@
+= jung
+
+Have you ever wondered how it would be if there were an easy way to send your message to billions of people?
+
+The Jung's collective unconscious will help in this arduous task!
+
+== Copyright
+
+Copyright (c) 2011 MobVox. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "jung"
+  gem.homepage = "http://github.com/mobvox/jung"
+  gem.license = "MIT"
+  gem.summary = %Q{TODO: one-line summary of your gem}
+  gem.description = %Q{TODO: longer description of your gem}
+  gem.email = "arielpts@me.com"
+  gem.authors = ["Ariel Patschiki"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "jung #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/jung.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "jung"
+  s.version     = File.read('VERSION')
+  s.authors     = ["arielpts", "danxexe"]
+  s.email       = ["arielpts@me.com"]
+  s.homepage    = "http://www.mobvox.com.br"
+  s.summary     = "Eletronic message deliver proxy"
+  s.description = "Have you ever wondered how it would be if there were an easy way to send your message to billions of people? The Jung’s collective unconscious will help in this arduous task!"
+
+  # s.rubyforge_project = "admin_widgets"
+
+  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_runtime_dependency "rest-client"
+
+  s.add_runtime_dependency "gibbon"
+  s.add_runtime_dependency "activesupport"
+  s.add_runtime_dependency "i18n"
+  s.add_runtime_dependency "rdoc"
+  s.add_runtime_dependency "gsm_encoder"
+end

data/lib/jung.rb

@@ -0,0 +1,10 @@
+require 'active_support/inflector'
+require 'gibbon'
+require 'pry'
+
+require 'jung/sender.rb'
+require 'jung/list.rb'
+require 'jung/campaign.rb'
+require 'jung/drivers.rb'
+require 'jung/config.rb'
+require 'jung/recipient.rb'

data/lib/jung/campaign.rb

@@ -0,0 +1,17 @@
+module Jung
+  class Campaign < Jung::List
+
+    attr_reader :id
+    attr_accessor :name, :sender, :subject, :message
+    
+    def initialize(options)
+      @name = options[:name]
+      @subject = options[:subject]
+      @sender = options[:sender]
+      @message = options[:message]
+
+      super options
+    end
+
+  end
+end

data/lib/jung/config.rb

@@ -0,0 +1,22 @@
+module Jung
+  class Config
+
+    attr_reader :driver, :options
+
+    def self.load(file = "config/jung.yml", namespace = nil)
+      options = YAML.load_file file
+      return self.new options[namespace.to_s]
+    end
+
+    def initialize(options)
+      @driver = options["driver"]
+      @options = options["options"]
+      Jung::Drivers.load options["driver"]
+    end
+
+    def driver_const
+      Jung::Drivers.const_get self.driver.camelize
+    end
+
+  end
+end

data/lib/jung/drivers.rb

@@ -0,0 +1,7 @@
+module Jung::Drivers
+
+  def self.load(name)
+    require File.join('jung', 'drivers', name)
+  end
+
+end

data/lib/jung/drivers/infobip.rb

@@ -0,0 +1,19 @@
+module Jung::Drivers::Infobip
+
+  require 'jung/drivers/infobip/api.rb'
+  require 'jung/drivers/infobip/campaign.rb'
+
+  attr_reader :list_id, :api, :id
+  attr_writer :list_id, :api
+
+  def self.extended(base)
+    return if base.class != Jung::Campaign
+    base.extend Jung::Drivers::Infobip::Campaign
+    base.api = Api.new base.config
+  end
+
+  def errors
+    api.errors
+  end
+
+end

data/lib/jung/drivers/infobip/api.rb

@@ -0,0 +1,71 @@
+class Jung::Drivers::Infobip::Api
+
+  require 'net/http'
+  require 'gsm_encoder'
+  require 'jung/drivers/infobip/sms_counter'
+
+  attr_reader :username, :password, :api_url, :error_messages
+  attr_accessor :errors
+
+  def initialize(config)
+    @username = config.options["username"]
+    @password = config.options["password"]
+    @api_url = config.options["api_url"]
+    @errors = []
+
+    @error_messages = {
+      -2 => "Not enough credits",
+      -3 => "Network not covered",
+      -5 => "Invalid username or password",
+      -6 => "Missing destination address",
+      -7 => "Missing SMS text",
+      -8 => "Missing sender name",
+      -9 => "Invalid format of destination address",
+      -10 => "Missing username",
+      -11 => "Missing password",
+      -13 => "Invalid destination address"
+    }
+  end
+
+  def send_sms(address, message, sender, options = {})
+    count = Jung::Drivers::Infobip::SmsCounter.count message.to_s
+
+    type = count[:messages] > 1 ? 'LongSMS' : nil
+    if count[:encoding] == :utf16
+      data_coding = 8
+      encoding = 'UTF-8'
+    else
+      data_coding = 1
+      encoding = nil
+      message = GSMEncoder.encode message
+    end
+
+    do_get_request :sendsms, {
+      :GSM => address, 
+      :SMSText => message, 
+      :sender => sender, 
+      :Type => type, 
+      :DataCoding => data_coding, 
+      :encoding => encoding,
+    }.merge(options)
+  end
+
+  private
+
+  def get_error_message id
+    error_messages[id.to_i] || "Unknow error ID: #{id}"
+  end
+
+  def do_get_request method, params
+    url  = api_url + '/' + method.to_s + '/plain?user=' + username + '&password=' + password
+    url = params.reduce(url) do | url, param |
+      url + '&' +  CGI.escape(param.first.to_s) + '=' + CGI.escape(param.last.to_s)
+    end
+    result = Net::HTTP.get_response(URI.parse(url)).body
+
+    self.errors << get_error_message(result)
+    
+    result.to_i > 1 ? result : false
+  end
+
+end

data/lib/jung/drivers/infobip/campaign.rb

@@ -0,0 +1,76 @@
+module Jung::Drivers::Infobip::Campaign
+
+  attr_accessor :username, :password, :api_url, :messages_ids
+  attr_accessor :app_id # Warning: Infobip limitation: app_id should not be more than 30 chars
+  attr_accessor :webhook
+
+  attr_reader :deliver_at
+  def deliver_at=(val)
+    @deliver_in = nil
+    @deliver_at = val
+  end
+
+  def deliver_in
+    return @deliver_in = nil unless deliver_at.respond_to?(:to_time)
+
+    @deliver_in ||= begin
+
+      time = deliver_at.to_time
+      seconds_from_now = (Time.now - time) * -1
+
+      unless seconds_from_now < 0
+        minutes_from_now, seconds_from_now = seconds_from_now.divmod(60)
+        hours_from_now, minutes_from_now = minutes_from_now.divmod(60)
+        days_from_now, hours_from_now = hours_from_now.divmod(24)
+        seconds_from_now = seconds_from_now.to_i
+
+        time_from_now = { 
+          :d => days_from_now,
+          :h => hours_from_now,
+          :m => minutes_from_now,
+          :s => seconds_from_now
+        }.reject { |k,v| v == 0 }.map { |(k,v)| "#{v}#{k}" }.join
+      else
+        time_from_now = nil
+      end
+
+      time_from_now
+    end
+  end
+
+
+  def deliver(recipients = self.recipients)
+    messages_ids = recipients.map do | recipient |
+      address = recipient.is_a?(Jung::Recipient) ? recipient.address : recipient
+      deliver_recipient address, message
+    end
+    delivery_success? messages_ids
+  end
+
+  def deliver_test(recipients)
+    deliver(recipients)
+  end
+
+  def schedule time
+    self.deliver_at = time
+    deliver
+  end
+
+
+  protected
+
+  def delivery_options
+    { :appid => app_id, :pushurl => webhook, :sendDateTime => deliver_in }.reject{ |k,v| v.nil? }
+  end
+
+  def deliver_recipient address, message
+    api.send_sms address, message, sender.name, delivery_options
+  end
+
+  def delivery_success?(messages_ids)
+    messages_ids.reduce(true) do | acc, value |
+      acc && value != false
+    end
+  end
+
+end

data/lib/jung/drivers/infobip/sms_counter.rb

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+module Jung::Drivers::Infobip
+
+  module SmsCounter
+
+    @gsm7bitChars = "@£$¥èéùìòÇ\nØø\rÅåΔ_ΦΓΛΩΠΨΣΘΞÆæßÉ !\"#¤%&'()*+,-./0123456789:;<=>?¡ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÑܧ¿abcdefghijklmnopqrstuvwxyzäöñüà"
+    @gsm7bitExChar = "^{}\\[~]|€"
+
+    @gsm7bitRegExp = Regexp.new("^[#{Regexp.escape(@gsm7bitChars)}]*$")
+    @gsm7bitExRegExp = Regexp.new("^[#{Regexp.escape(@gsm7bitChars)}#{Regexp.escape(@gsm7bitExChar)}]*$")
+    @gsm7bitExOnlyRegExp = Regexp.new("^[\\#{Regexp.escape(@gsm7bitExChar)}]*$")
+
+    @messageLength = {
+      :gsm_7bit => 160,
+      :gsm_7bit_ex => 160,
+      :utf16 => 70
+    }
+
+    @multiMessageLength = {
+      :gsm_7bit => 153,
+      :gsm_7bit_ex => 153,
+      :utf16 => 67
+    }
+
+    def self.count(text)
+      encoding = detectEncoding(text)
+
+      length = text.length
+      length += countGsm7bitEx(text) if encoding == :gsm_7bit_ex
+
+      per_message = @messageLength[encoding]
+      per_message = @multiMessageLength[encoding] if length > per_message
+
+      messages = (length.to_f / per_message).ceil
+      remaining = (per_message * messages) - length
+
+      {
+        :encoding => encoding,
+        :length => length,
+        :per_message => per_message,
+        :remaining => remaining,
+        :messages => messages
+      }
+    end
+
+    def self.detectEncoding(text)
+      case
+        when text.match(@gsm7bitRegExp) then :gsm_7bit
+        when text.match(@gsm7bitExRegExp) then :gsm_7bit_ex
+        else :utf16
+      end
+    end
+
+    def self.countGsm7bitEx(text)
+      chars = text.each_char.select {|char| char.match(@gsm7bitExOnlyRegExp) }
+      chars.size
+    end
+
+  end
+
+end

data/lib/jung/drivers/mailchimp.rb

@@ -0,0 +1,22 @@
+module Jung::Drivers::Mailchimp
+
+  require 'jung/drivers/mailchimp/api.rb'
+  require 'jung/drivers/mailchimp/list.rb'
+  require 'jung/drivers/mailchimp/campaign.rb'
+
+  attr_reader :gb, :list_id, :api, :id
+  attr_writer :gb, :list_id, :api
+
+  def self.extended(base)
+    base.extend Jung::Drivers::Mailchimp::List
+    base.extend Jung::Drivers::Mailchimp::Campaign if base.class == Jung::Campaign
+  
+    base.list_id = base.config.options[:list_id]
+    base.api = Api.new base.config
+  end
+
+  def errors
+    api.errors
+  end
+
+end

data/lib/jung/drivers/mailchimp/api.rb

@@ -0,0 +1,210 @@
+class Jung::Drivers::Mailchimp::Api
+
+  attr_reader :config, :gb, :list_id
+  attr_accessor :errors
+
+  def initialize(config)
+    @config = config
+    @gb = Gibbon.new config.options["api_key"]
+    @list_id = config.options["list_id"]
+    @errors = []
+  end
+
+  # List Related
+
+  def list_ensure_merge_vars(recipient)
+    recipient.attribute_names.map do |attribute_name|
+      list_merge_var_add(attribute_name)
+    end.reduce &:&
+  end
+
+  def list_merge_var_add(merge_var)
+    tag = merge_var.to_s.upcase
+    name = tag.capitalize
+
+    @merge_vars ||= list_merge_vars
+
+    return true unless !@merge_vars.include? tag
+
+    # Cache is never ugly
+    @merge_vars << tag
+
+    gb.list_merge_var_add({
+      :id => list_id,
+      :tag => tag,
+      :name => name
+    })
+  end
+
+  def list_merge_vars
+    merge_vars_array = gb.list_merge_vars :id => list_id
+    merge_vars_array.map { |e| e["tag"] }
+  end
+
+  def list_subscribe(recipient)  
+    merge_vars = recipient.attributes.inject("FNAME" => recipient.name) do |attributes, (k, v)|
+      attributes[k.to_s.upcase] = v
+      attributes
+    end
+  
+    add_errors_and_return(gb.list_subscribe({
+      :id => list_id,
+      :email_address => recipient.address,
+      :merge_vars => merge_vars,
+      :double_optin => false,
+      :update_existing => true
+    })) { self == true }
+  end
+
+  def list_unsubscribe(address)
+    gb.list_unsubscribe({
+      :id => list_id,
+      :email_address => address,
+      :delete_member => false,
+      :send_goodbye => false
+    })
+  end
+
+  def list_members
+    current_members = []
+    members_array = gb.list_members :id => list_id, :limit => 15000
+    members_array["data"].each do |member|
+      # TODO: Batch this method (Mailchimp supports up to 50 per call)
+      info = gb.list_member_info :id => list_id, :email_address => member["email"]
+
+      attributes = { :name => info["data"][0]["merges"].delete("FNAME"), :address => info["data"][0]["merges"].delete("EMAIL") }
+      info["data"][0]["merges"].each_pair do |k, v|
+        attributes[k.downcase.to_sym] = v
+      end
+
+      current_members << Jung::Recipient.new(attributes)
+    end
+    current_members
+  end
+
+  def list_static_segments
+    gb.list_static_segments(:id => list_id).reduce({}) do | acc, v |
+      acc[v["name"]] = v["id"]
+      acc
+    end
+  end
+
+  def list_wipe_static_segments
+    # TODO: Call this only to unused segments. Internal use only for now.
+    list_static_segments.each do | campaign_id, segment_id |
+      list_static_segment_delete segment_id
+    end
+  end
+
+  def find_or_add_static_segment name
+    list_static_segment_find(name) || 
+    list_static_segment_add(name)
+  end
+
+  def list_static_segment_add name
+    gb.list_static_segment_add :id => list_id, :name => name
+  end
+
+  def list_static_segment_find name
+    static_segments = list_static_segments
+    static_segments[name]
+  end
+
+  def list_static_segment_reset static_segment_id
+    gb.list_static_segment_members_add :id => list_id, :seg_id => static_segment_id
+  end
+
+  def list_static_segment_delete static_segment_id
+    gb.list_static_segment_del :id => list_id, :seg_id => static_segment_id
+  end  
+
+  def list_static_segment_members_add static_segment_id, emails
+    add_errors_and_return(gb.list_static_segment_members_add({
+      :id => list_id,
+      :seg_id => static_segment_id,
+      :batch => emails
+    })) { self["success"] == emails.count }
+  end
+
+  # Campaign Related
+
+  def all_campaigns
+    gb.campaigns({ :filters => { :list_id => list_id } })
+  end
+
+  def campaign_create campaign
+    add_errors_and_return(gb.campaign_create({ 
+      :type => :regular,
+      :options => {
+        :list_id => list_id,
+        :title => campaign.name,
+        :subject => campaign.subject,
+        :from_name => campaign.sender.name,
+        :from_email => campaign.sender.address,
+        :to_name => '*|FNAME|*',
+        :generate_text => true,
+        :fb_comments => false,
+        :inline_css => config.options["inline_css"] || true
+      },
+      :content => {
+        :html => campaign.message
+      }
+    })) { gsub(/\"/, '') }
+  end
+
+  def campaign_update campaign
+    # campaign.pry
+  end
+
+  def campaign id
+    add_errors_and_return(gb.campaigns({
+      :filters => {
+        :campaign_id => id
+      }
+    })) { self["data"].first }
+  end
+
+  def campaign_content id
+    campaign_content = gb.campaign_content :cid => id
+    campaign_content["html"]
+  end
+
+  def campaign_send_now id
+    gb.campaign_send_now :cid => id
+  end
+
+  def campaign_send_test id, recipients
+    gb.campaign_send_test :cid => id, :test_emails => recipients
+  end
+
+  def campaign_delete id
+    gb.campaign_delete :cid => id
+  end
+
+  def campaign_update_static_segment id, static_segment_id
+    gb.campaign_update :cid => id, :name => "segment_opts", :value => {
+      :match => "all",
+      :conditions => [{ :field => "static_segment", :op => "eq", :value => static_segment_id }]
+    }
+  end
+
+  def campaign_schedule id, time
+    gb.campaign_schedule :cid => id, :schedule_time => time.utc.strftime('%Y-%m-%d %H:%M:%S')
+  end
+
+  def campaign_unschedule id
+    gb.campaign_unschedule :cid => id
+  end
+
+  private
+
+  def add_errors_and_return(result, &proc)
+    if result.is_a?(Hash) && result["error"]
+      self.errors ||= [] << result["code"].to_s + ' - ' + result["error"]
+      false
+    else
+      result.instance_eval(&proc)
+    end
+  end
+
+end

data/lib/jung/drivers/mailchimp/campaign.rb

@@ -0,0 +1,86 @@
+module Jung::Drivers::Mailchimp::Campaign
+
+  def find(id)
+    @id = id
+    campaign = api.campaign id
+
+    return false if !campaign
+
+    campaign_content = api.campaign_content id
+    
+    @name = campaign["title"]
+    @subject = campaign["subject"]
+    @message = campaign_content
+    @sender = Jung::Sender.new(campaign["from_name"], campaign["from_email"])
+  end
+
+  def save
+    # if sync_merge_vars &&
+    if sync_members &&
+       sync_campaign &&
+       sync_static_segments
+      @id
+    end
+  end
+
+  def deliver
+    api.campaign_send_now(id) if save
+  end
+
+  def deliver_test(recipients)
+    api.campaign_send_test(id, recipients) if save
+  end
+
+  def schedule time
+    api.campaign_schedule(id, time) if save
+  end
+
+  def unschedule
+    api.campaign_unschedule(id) if id
+  end
+
+  def delete
+    delete_static_segment &&
+    api.campaign_delete(id) &&
+    reset 
+  end
+
+  def all
+    api.all_campaigns
+  end
+
+  protected
+
+  def reset
+    @id = nil
+    true
+  end
+
+  def sync_campaign
+    # TODO: Refactor with ||
+    if id
+      api.campaign_update self
+      puts "Not Yet Supported"
+    else
+      @id = api.campaign_create self
+    end
+    self.id
+  end
+
+  def delete_static_segment
+    static_segment_id = api.list_static_segment_find id
+    api.list_static_segment_delete static_segment_id
+  end
+
+  def sync_static_segments
+    # Dont list_wipe_static_segments yet!
+    # api.list_wipe_static_segments
+    # The segment name is the campaign internal id. Creates one static segment per campaign
+    static_segment_id = api.find_or_add_static_segment id
+    api.list_static_segment_reset static_segment_id
+    emails = recipients.map { |recipient| recipient.address }
+    api.list_static_segment_members_add static_segment_id, emails
+    api.campaign_update_static_segment id, static_segment_id
+  end
+
+end

data/lib/jung/drivers/mailchimp/list.rb

@@ -0,0 +1,40 @@
+ module Jung::Drivers::Mailchimp::List
+
+  def save
+    sync_merge_vars &&
+    sync_members &&
+    delete_non_members
+  end
+
+  def all
+    api.list_members
+  end
+
+  protected
+
+  def sync_merge_vars
+    return true if recipients.count == 0
+    (recipients.map do |recipient|
+      api.list_ensure_merge_vars(recipient)
+    end).reduce &:&
+  end
+
+  def sync_members
+    return true if recipients.count == 0
+    (recipients.map { |recipient| api.list_subscribe(recipient) }).reduce &:&
+  end
+
+  def delete_non_members
+    # Unsubscribe non-existing members
+    # Call this method *ONLY* with a full list of all members
+    current_members = api.list_members
+    current_members.each do |member|
+      res = find_recipient_by_address member.address
+      if !find_recipient_by_address member.address
+        api.list_unsubscribe member.address
+      end
+    end
+    true
+  end
+
+end

data/lib/jung/list.rb

@@ -0,0 +1,30 @@
+module Jung
+  class List
+    
+    attr_reader :config
+    attr_accessor :recipients
+
+    def initialize(options)
+      @config = options[:config]
+      @recipients = []
+
+      self.load_driver
+    end
+
+    def load_driver
+      self.extend config.driver_const
+    end
+
+    def create_recipient(attributes)
+      self.recipients << Jung::Recipient.new(attributes)
+    end
+
+    def find_recipient_by_address(address)
+      recipients.each do |recipient|
+        return recipient if recipient.address == address
+      end
+      return nil
+    end
+
+  end
+end

data/lib/jung/recipient.rb

@@ -0,0 +1,55 @@
+module Jung
+  class Recipient
+
+    attr_accessor :name, :address
+    attr_reader :attribute_names
+    attr_reader :attributes
+
+    def initialize(attributes)
+      @attribute_names = []
+      @attributes = {}
+
+      @name = attributes.delete(:name)
+      @address = attributes.delete(:address)
+
+      @attribute_names = attributes.keys.uniq.map(&:to_sym)
+
+      attributes.each_pair do |k, v|
+        @attributes[k.to_sym] = v
+      end
+    end
+
+    def get_attribute(attr_name)
+      @attributes[attr_name]
+    end
+
+    def set_attribute(attr_name, value)
+      @attributes[attr_name] = value
+    end
+
+    def attribute_method?(method_name)
+      match = method_name.to_s.match(/^(?<attr_name>.*?)(?<setter>=?)$/)
+      accessor = match[:setter] == '=' ? :set : :get
+      attr_name = match[:attr_name].to_sym
+      attribute_names.include?(attr_name) ? [accessor, attr_name] : false
+    end
+
+    def method_missing(method_name, *args, &block)
+      accessor, attr_name = attribute_method?(method_name)
+      if accessor
+        send("#{accessor}_attribute", attr_name, *args, &block)
+      else
+        super method_name, *args, &block
+      end
+    end
+
+    def respond_to?(method_name, include_private = false)
+      if attribute_method?(method_name)
+        true
+      else
+        super method_name, include_private
+      end
+    end
+
+  end
+end

data/lib/jung/sender.rb

@@ -0,0 +1,12 @@
+module Jung
+  class Sender
+
+    attr_accessor :name, :address
+
+    def initialize(name, address = nil)
+      @name = name
+      @address = address
+    end
+
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'jung'
+
+class Test::Unit::TestCase
+end

data/test/test_jung_infobip.rb

@@ -0,0 +1,29 @@
+require 'helper'
+
+class TestJung < Test::Unit::TestCase
+
+  def config
+    config_file_name = File.join(Pathname.new(__FILE__).dirname, "config/jung.yml")
+    @config ||= Jung::Config.load config_file_name, :test_infobip
+  end
+
+  def test_campaign_deliver
+    # First lets define a campaign
+    rand = rand(123 * 456)
+    campaign = Jung::Campaign.new({
+      :config => config,
+      :name => 'JUNG TEST - Lorem ipsum dolor. #' + rand.to_s,
+      :sender => Jung::Sender.new('Lorem ipsum')
+    })
+
+    # Add the recipients
+    campaign.create_recipient :name => 'Lorem', :address => config.options["fixtures"]["test_phone1"]
+    campaign.create_recipient :name => 'Lipsum', :address => config.options["fixtures"]["test_phone2"]
+    
+    campaign.message = campaign.name
+
+    assert campaign.deliver
+
+  end
+
+end

data/test/test_jung_mailchimp.rb

@@ -0,0 +1,71 @@
+require 'helper'
+
+class TestJung < Test::Unit::TestCase
+
+  def config
+    config_file_name = File.join(Pathname.new(__FILE__).dirname, "config/jung.yml")
+    @config ||= Jung::Config.load config_file_name, :test_mailchimp
+  end
+
+  def test_list_save
+    list = Jung::List.new :config => config
+
+    list.create_recipient :name => 'Lorem', :address => 'lorem@mobvox.com.br', :sex => 'm', :function => "Developer", :phone => '33554466'
+    list.create_recipient :name => 'Ipsum', :address => 'ipsum@mobvox.com.br', :sex => 'm', :function => "Developer"
+    list.create_recipient :name => 'Dolor', :address => 'dolor@mobvox.com.br', :sex => 'm', :function => "Developer"
+    list.create_recipient :name => 'Sit', :address => 'sit@mobvox.com.br', :sex => 'm', :function => "Developer"
+    list.create_recipient :name => 'Amet', :address => 'amet@mobvox.com.br', :sex => 'm', :function => "Developer"
+    list.create_recipient :name => 'Consectetur', :address => 'consectetur@mobvox.com.br', :sex => 'f', :function => "Developer"
+    list.create_recipient :name => 'Adipiscing', :address => 'adipiscing@mobvox.com.br', :sex => 'm', :function => "Psychologist"
+
+    assert list.save
+  end
+
+  def test_campaign_save_find_delete
+    # First lets save a campaign
+    rand = rand(123 * 456)
+    campaign = Jung::Campaign.new({
+      :config => config,
+      :name => 'JUNG TEST - Lorem ipsum dolor. #' + rand.to_s,
+      :subject => 'Fusce tempus, nibh eleifend feugiat lobortis.',
+      :sender => Jung::Sender.new('Lorem ipsum', 'contato@mobvox.com.br')
+    })
+    campaign.create_recipient :name => 'Lorem', :address => 'lorem@mobvox.com.br', :sex => 'm', :function => "Developer", :phone => '33554466'
+    campaign.create_recipient :name => 'Ipsum', :address => 'ipsum@mobvox.com.br', :sex => 'm', :function => "Developer"
+    id = campaign.save
+    assert id != nil
+    
+    # Now lets "find" the campaign
+    campaign = Jung::Campaign.new :config => config
+    if !campaign.find id
+      puts campaign.errors.inspect
+    end
+    assert campaign.id != nil
+
+    # And delete it!
+    assert campaign.delete
+  end
+
+  def test_campaign_schedule_unschedule_delete
+    # First lets define a campaign
+    rand = rand(123 * 456)
+    campaign = Jung::Campaign.new({
+      :config => config,
+      :name => 'JUNG TEST - Lorem ipsum dolor. #' + rand.to_s,
+      :subject => 'Fusce tempus, nibh eleifend feugiat lobortis.',
+      :sender => Jung::Sender.new('Lorem ipsum', 'contato@mobvox.com.br')
+    })
+
+    # Add one recipient
+    campaign.create_recipient :name => 'Lorem', :address => 'lorem@mobvox.com.br', :sex => 'm', :function => "Developer", :phone => '33554466'
+    
+    campaign.subject = campaign.name
+    campaign.message = campaign.name
+
+    assert campaign.schedule Time.now + (60 * 60 * 24)
+    assert campaign.unschedule
+    # assert campaign.deliver
+    assert campaign.delete
+  end
+
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: jung
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+  prerelease: 
+platform: ruby
+authors:
+- arielpts
+- danxexe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gibbon
+  requirement: &2153125540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153125540
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2153125100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153125100
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &2153124680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153124680
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &2153124260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153124260
+- !ruby/object:Gem::Dependency
+  name: gsm_encoder
+  requirement: &2153123840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153123840
+description: Have you ever wondered how it would be if there were an easy way to send
+  your message to billions of people? The Jung’s collective unconscious will help
+  in this arduous task!
+email:
+- arielpts@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- jung.gemspec
+- lib/jung.rb
+- lib/jung/campaign.rb
+- lib/jung/config.rb
+- lib/jung/drivers.rb
+- lib/jung/drivers/infobip.rb
+- lib/jung/drivers/infobip/api.rb
+- lib/jung/drivers/infobip/campaign.rb
+- lib/jung/drivers/infobip/sms_counter.rb
+- lib/jung/drivers/mailchimp.rb
+- lib/jung/drivers/mailchimp/api.rb
+- lib/jung/drivers/mailchimp/campaign.rb
+- lib/jung/drivers/mailchimp/list.rb
+- lib/jung/list.rb
+- lib/jung/recipient.rb
+- lib/jung/sender.rb
+- test/helper.rb
+- test/test_jung_infobip.rb
+- test/test_jung_mailchimp.rb
+homepage: http://www.mobvox.com.br
+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: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Eletronic message deliver proxy
+test_files:
+- test/helper.rb
+- test/test_jung_infobip.rb
+- test/test_jung_mailchimp.rb
+has_rdoc: