citrus-mail 0.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.0"
+  gem "rcov", ">= 0"
+  gem 'shoulda'
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.0)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.0)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Galdomedia
+
+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,95 @@
+= citrus-mail
+
+Description goes here.
+
+== Example usage
+
+=== Creating list instance(representing freshmial subscription list):
+
+You can create client instance and then get list
+    @client = CitrusMail::Client.new('your_api_key')
+    @list = @client.get_list('your_list_key')
+
+or create list
+
+    @list = CitrusMail::List.new('you_api_key', 'your_list_key')
+
+=== Available CitrusMail::List methods
+
+===== @list.add_subscriber(email, name, custom_fields, options)
+Adds new subscriber with given email.
+
+Params:
+* name: name for subscriber(default: nil)
+* cusom_fields: custom fileds for subscriber(default: {})
+* options: only one option exists 'confirm_email' (if true subscriber will get email with confirmation link) (default: {:confirm_email => true})
+
+
+===== @list.confirm(email)
+Confirm subscriber with given email.
+
+===== @list.add_and_confirm_subscriber(email)
+Add new subscriber with given email and make it confirmed.
+
+Params are the same as in add_subscriber method, except options[:confirm_email] which is always false.
+
+===== @list.modify_subscriber(emial, fields)
+Modify subscriber with given email.
+
+Params:
+* fields: fields to change. :name is maped to 'freshmail_name' , and every else is maped to 'freshmail_custom_field' (default: {})
+
+===== @list.change_state(identifier, state)
+Modify state subscriber with given email.
+
+Params:
+* state(Fixnum): possible values: 4 - unsubscribed, 6 - removed
+
+===== @list.get_empty_fields(email)
+Get empty fields for subscriber with given email.
+
+===== @list.remove(email)
+Remove(unsubscribe) subscriber with given email.
+
+
+All this methods will raise
+* CitrusMail::RequestFailed if http request faild
+* CitrusMail::InvalidAPIKey if api key is invalid (FreshMail return code 104)
+* CitrusMail::InvalidListKey if list key is invalid (FreshMail return code 101)
+* CitrusMail::InvalidEmail if email is invalid (FreshMail return code 202)
+* CitrusMail::EmailExists if email already exists for list (FreshMail return code 201)
+* CitrusMail::SubscriberNotExists if subscriber not exists (FreshMail return code 206)
+All above exceptions are descendants of CitrusMail::CitrusMailError.
+* and CitrusMail::CitrusMailError if FreshMail return code is greater than 100
+
+=== CitrusMail::Response
+After each call to FreshMail api, CitrusMail::Response object is created.
+CitrusMail::Response is responsible for parsing http response, and raise CitrusMail exceptions if needed.
+You can access CitrusMail::Response instance by calling :response method of CitrusMail::List object.
+Example:
+
+  @list = CitrusMail::List.new('you_api_key', 'your_list_key')
+  @list.response # => nil
+  @list.add_subscriber('test@test.com')
+  @resposne = @list.response
+Accessing http response:
+  @response.http_response # => #<Net::HTTPOK 200 OK readbody=true>
+Accessing FreshMail code:
+  @response.code # => 2
+Accessing FreshMail response (value of <response> xml tag returned by FreshMail)
+  @response.freshmail_response # => '2'
+
+== Contributing to citrus-mail
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Galdomedia. 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 = "citrus-mail"
+  gem.homepage = "https://github.com/galdomedia/citrus-mail"
+  gem.license = "MIT"
+  gem.summary = %Q{Nifty Rails gem for nice FreshMail integration}
+  gem.description = %Q{Gem that gives you easy integration with polish mailing service FreshMail (freshmail.pl)}
+  gem.email = "piotr@galdomedia.pl"
+  gem.authors = ["Piotr Boniecki", "GaldoMedia"]
+  # 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 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "citrus-test #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/citrus-mail.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{citrus-mail}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Piotr Boniecki", "GaldoMedia"]
+  s.date = %q{2011-05-17}
+  s.description = %q{Gem that gives you easy integration with polish mailing service FreshMail (freshmail.pl)}
+  s.email = %q{piotr@galdomedia.pl}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "citrus-mail.gemspec",
+    "lib/citrus_mail.rb",
+    "lib/citrus_mail/client.rb",
+    "lib/citrus_mail/list.rb",
+    "lib/citrus_mail/response.rb",
+    "test/helper.rb",
+    "test/test_client.rb",
+    "test/test_list.rb",
+    "test/test_response.rb"
+  ]
+  s.homepage = %q{https://github.com/galdomedia/citrus-mail}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Nifty Rails gem for nice FreshMail integration}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<shoulda>, [">= 0"])
+  end
+end
+

data/lib/citrus_mail.rb

@@ -0,0 +1,67 @@
+module CitrusMail
+  HOST = 'https://app.freshmail.pl'
+  ERRORS = {
+      101 => 'niepoprawny klucz określający listę subskrypcyjną',
+      102 => 'brak wymaganego pola email',
+      103 => 'klucze identyfikujące pola dodatkowe nie należą do tej listy subskrypcyjnej',
+      104 => 'klucz identyfikujący api jest niepoprawny',
+      201 => 'podany email jest już zapisany do danej listy subskrypcyjnej',
+      202 => 'podany adres email jest niepoprawny',
+      203 => 'długość znaków dla pól dodatkowych, bądź nazwy została przekroczona',
+      204 => 'podane kodowanie znaków jest nieprawidłowe',
+      205 => 'dane wprowadzone od pól dodatkowych przekraczają dozwoloną długość 255 znaków',
+      206 => 'nie ma takiego subskrybenta',
+      207 => 'niepoprawne kodowanie',
+      999 => 'błąd połączenia do bazy danych'
+  }
+
+  class CitrusMailError < StandardError
+    def initialize(code_or_message=nil)
+      if code_or_message.is_a?(Fixnum)
+        code_or_message = "#{code_or_message} - #{CitrusMail::ERRORS[code_or_message] || "Unknown error"}"
+      end
+      super(code_or_message)
+    end
+  end
+
+  #raised when http request is failed
+  class RequestFailed < CitrusMailError
+
+  end
+
+  #raised when api key is invalid (FreshMail return code 104)
+  class InvalidAPIKey < CitrusMailError
+
+  end
+
+  #raised when list key is invalid (FreshMail return code 101)
+  class InvalidListKey < CitrusMailError
+
+  end
+
+  #raised when email is invalid (FreshMail return code 202)
+  class InvalidEmail < CitrusMailError
+
+  end
+
+  #raised when email already exists for list (FreshMail return code 201)
+  class EmailExists < CitrusMailError
+
+  end
+
+  #raised when subscriber not exists (FreshMail return code 206)
+  class SubscriberNotExists < CitrusMailError
+
+  end
+end
+
+require 'citrus_mail/client'
+require 'citrus_mail/list'
+require 'citrus_mail/response'
+
+# jtidhzdxlp
+
+#require 'citrus_mail'
+#cm = CitrusMail::Client.new('0633bb5ff7191ff48c4f065aa17f0321')
+#list = cm.get_list('hi03a662gw')
+#r = list.add_subscriber('piotr@galdomedia.pl')

data/lib/citrus_mail/client.rb

@@ -0,0 +1,77 @@
+require 'net/http'
+require 'net/https'
+
+module CitrusMail
+  class Client
+    attr_accessor :api_key, :encoding
+
+    def initialize(api_key, options={})
+      @api_key = api_key
+      @encoding = options[:encoding] if options[:encoding]
+    end
+
+    def get_list(key)
+      List.new(self, key)
+    end
+
+    #actions = [modify, get_empty_fields, change_state, confirm, remove, add_subscriber]
+    def path_for(action)
+      "/main.php?moduleName=fm_api&action=#{action}"
+    end
+
+    def connection
+      @connection ||= begin
+        uri = URI.parse(HOST)
+        connection = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == "https" # enable SSL/TLS
+          connection.use_ssl = true
+          connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        connection
+      end
+    end
+
+    def http_get(url, params)
+      response = connection.start do |http|
+        url_with_params = url + "&" + process_params(params).map { |k, v| "#{urlencode(k.to_s)}=#{urlencode(v.to_s)}" }.join('&')
+        get = Net::HTTP::Get.new(url_with_params)
+        http.request(get)
+      end
+      Net::HTTPOK
+      CitrusMail::Response.build_from_http_response(response)
+    end
+
+    def http_post(path, params)
+      response = connection.start do |http|
+        post = Net::HTTP::Post.new(path)
+        post.set_form_data(process_params(params))
+        http.request(post)
+      end
+      CitrusMail::Response.build_from_http_response(response)
+    end
+
+    def process_params(params)
+      hash = {:api_key => api_key}
+      hash[:encoding] = @encoding if @encoding
+      hash.merge!(params)
+      flatten_params(hash)
+    end
+
+    def flatten_params(params)
+      params.inject({}) do |h, (key, value)|
+        if value.is_a?(Hash)
+          value.each_pair { |k, v| h["#{key}[#{k}]"] = v.to_s }
+        else
+          h[key] = value.to_s
+        end
+        h
+      end
+    end
+
+    #copied from ''net/http'
+    def urlencode(str)
+      str.gsub(/[^a-zA-Z0-9_\.\-]/n) { |s| sprintf('%%%02x', s[0]) }
+    end
+
+  end
+end

data/lib/citrus_mail/list.rb

@@ -0,0 +1,90 @@
+module CitrusMail
+  class List
+    attr_accessor :key, :client, :response
+
+    def initialize(client_or_api_key, key)
+      @key = key
+      if client_or_api_key.is_a?(CitrusMail::Client)
+        @client = client_or_api_key
+      else
+        @client = CitrusMail::Client.new(client_or_api_key)
+      end
+    end
+
+    def add_subscriber(email, name=nil, custom_fields={}, options={:confirm_email => true})
+      params = {:freshmail_email => email}
+      params[:freshmail_name] = name if name
+      params[:freshmail_custom_field] = custom_fields if custom_fields.empty?
+      unless options[:confirm_email].nil?
+        params[:confirm_email] = options[:confirm_email]
+      end
+
+      path = client.path_for(:add_subscriber)
+      make_post_request(path, params)
+    end
+
+    def confirm(identifier)
+      params = {:freshmail_subscriber => identifier}
+
+      path = client.path_for(:confirm)
+      make_get_request(path, params)
+    end
+
+    def add_and_confirm_subscriber(email, name=nil, custom_fields={}, options={})
+      options[:confirm_email] = false
+      add_subscriber(email, name, custom_fields, options)
+      confirm(email)
+    end
+
+    def modify_subscriber(email, fields={})
+      params = {:freshmail_subscriber => email}
+      if name = fields.delete(:name)
+        params[:freshmail_name] = name
+      end
+      params[:freshmail_custom_field] = fields unless fields.empty?
+
+      path = client.path_for(:modify)
+      make_post_request(path, params)
+    end
+
+    #4 – subskrybent wypisany
+    #6 – subskrybent skasowany
+    def change_state(identifier, state)
+      params = {:freshmail_subscriber => identifier, :state => state}
+
+      path = client.path_for(:change_state)
+      make_post_request(path, params)
+    end
+
+    def get_empty_fields(email)
+      params = {:freshmail_subscriber => email}
+
+      path = client.path_for(:get_empty_fields)
+      make_get_request(path, params)
+    end
+
+    def remove(identifier)
+      params = {:freshmail_subscriber => identifier}
+
+      path = client.path_for(:remove)
+      make_get_request(path, params)
+    end
+
+    protected
+
+    def make_post_request(path, params)
+      self.response = nil
+      params = {:freshmail_list => key}.merge(params)
+      self.response = client.http_post(path, params)
+      response.code
+    end
+
+    def make_get_request(path, params)
+      self.response = nil
+      params = {:freshmail_list => key}.merge(params)
+      self.response = client.http_get(path, params)
+      response.code
+    end
+
+  end
+end

data/lib/citrus_mail/response.rb

@@ -0,0 +1,35 @@
+module CitrusMail
+  class Response
+    attr_accessor :http_response, :code, :freshmail_response
+
+    def self.build_from_http_response(http_response)
+      response = self.new()
+      response.http_response = http_response
+      response.process_http_response
+      response
+    end
+
+    def process_http_response
+      if http_response.code.to_i == 200 and res = (r = http_response.body.match(/\<response\>(.*)\<\/response\>/) and r[1])
+        self.freshmail_response = res
+        self.code = res.to_i
+        if code > 100
+          raise InvalidListKey.new(code) if code == 101
+          raise InvalidAPIKey.new(code) if code == 104
+          raise EmailExists.new(code) if code == 201
+          raise InvalidEmail.new(code) if code == 202
+          raise SubscriberNotExists.new(code) if code == 206
+
+          raise CitrusMailError.new(code)
+        end
+      else
+        raise RequestFailed
+      end
+    end
+
+    def parse_json_freshmail_response
+      ActiveSupport::JSON.decode freshmail_response
+    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.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'citrus_mail'
+
+class Test::Unit::TestCase
+end

data/test/test_client.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class TestClient < Test::Unit::TestCase
+
+  context "CitrusMail::Client" do
+    setup do
+      @api_key = 'fake_key'
+      @client = CitrusMail::Client.new(@api_key)
+    end
+
+    context "#flatten_params with {'a' => 'b', 'c' => {'d' => 'e', 'f' => 'g'}}" do
+      should "return {'a' => 'b', 'c[d]' => 'e', 'c[f]' => 'g'}" do
+        params = {'a' => 'b', 'c' => {'d' => 'e', 'f' => 'g'}}
+        ret = @client.flatten_params(params)
+        assert ret == {'a' => 'b', 'c[d]' => 'e', 'c[f]' => 'g'}
+      end
+    end
+
+    context "#process_params with {'a' => 'b'}" do
+      should "return {'a' => 'b', :api_key => 'fake_key'}" do
+        params = {'a' => 'b'}
+        ret = @client.process_params(params)
+        assert ret == {'a' => 'b', :api_key => @api_key}
+      end
+    end
+
+    context "#get_list with list_key" do
+      setup do
+        @list_key = "fake_list_key"
+      end
+
+      should "return CitrusMail::List instance" do
+        list = @client.get_list(@list_key)
+        assert list.is_a?(CitrusMail::List)
+      end
+    end
+
+  end
+
+end

data/test/test_list.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class TestList < Test::Unit::TestCase
+
+  context "CitrusMail::List" do
+    setup do
+      @api_key = 'fake_key'
+      @list_key = 'fake_list_key'
+    end
+
+    should "should be properly initialized and initialize client instance" do
+      list = CitrusMail::List.new(@api_key, @list_key)
+      assert list.client.is_a?(CitrusMail::Client)
+    end
+  end
+
+  context "CitrusMail::List" do
+    setup do
+      @api_key = 'fake_key'
+      @client = CitrusMail::Client.new(@api_key)
+      @list_key = 'fake_list_key'
+      @list = @client.get_list(@list_key)
+    end
+
+    should "" do
+      assert true
+    end
+  end
+
+end

data/test/test_response.rb

@@ -0,0 +1,83 @@
+require 'helper'
+
+class FakeHttpResponse < Struct.new(:code, :body)
+end
+
+class TestResponse < Test::Unit::TestCase
+
+  context "CitrusMail::Response" do
+    setup do
+    end
+
+    context "when http code is not 200" do
+      setup do
+        @http_response = FakeHttpResponse.new('100', '<root><response>1</response></root>')
+      end
+      should "raise CitrusMail::RequestFailed" do
+        exception = nil
+        begin
+          CitrusMail::Response.build_from_http_response(@http_response)
+        rescue => e
+          exception = e
+        end
+        assert exception.is_a?(CitrusMail::RequestFailed)
+      end
+    end
+
+    context "when http code is 200 and response body has no <response> xml tag" do
+      setup do
+        @http_response = FakeHttpResponse.new('200', 'something')
+      end
+      should "raise CitrusMail::RequestFailed" do
+        exception = nil
+        begin
+          CitrusMail::Response.build_from_http_response(@http_response)
+        rescue => e
+          exception = e
+        end
+        assert exception.is_a?(CitrusMail::RequestFailed)
+      end
+    end
+
+    context "when freshmail response is greater than 100" do
+      setup do
+        @http_response = FakeHttpResponse.new('200', '<root><response>201</response></root>')
+      end
+      should "raise CitrusMail::CitrusMailError" do
+        exception = nil
+        begin
+          CitrusMail::Response.build_from_http_response(@http_response)
+        rescue => e
+          exception = e
+        end
+        assert exception.is_a?(CitrusMail::CitrusMailError)
+      end
+    end
+
+    context "when freshmail response is greater than 100" do
+      setup do
+        @http_response = FakeHttpResponse.new('200', '<root><response>201</response></root>')
+      end
+      should "raise CitrusMail::CitrusMailError" do
+        exception = nil
+        begin
+          CitrusMail::Response.build_from_http_response(@http_response)
+        rescue => e
+          exception = e
+        end
+        assert exception.is_a?(CitrusMail::CitrusMailError)
+      end
+    end
+
+    context "when freshmail response is lower than 100" do
+      setup do
+        @http_response = FakeHttpResponse.new('200', '<root><response>1</response></root>')
+      end
+      should "return CitrusMail::Response" do
+        ret = CitrusMail::Response.build_from_http_response(@http_response)
+        assert ret.is_a?(CitrusMail::Response)
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: citrus-mail
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Piotr Boniecki
+- GaldoMedia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  prerelease: false
+  requirement: *id001
+  name: bundler
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 0
+        version: 1.6.0
+  prerelease: false
+  requirement: *id002
+  name: jeweler
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  requirement: *id003
+  name: rcov
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  requirement: *id004
+  name: shoulda
+  type: :development
+description: Gem that gives you easy integration with polish mailing service FreshMail (freshmail.pl)
+email: piotr@galdomedia.pl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- citrus-mail.gemspec
+- lib/citrus_mail.rb
+- lib/citrus_mail/client.rb
+- lib/citrus_mail/list.rb
+- lib/citrus_mail/response.rb
+- test/helper.rb
+- test/test_client.rb
+- test/test_list.rb
+- test/test_response.rb
+has_rdoc: true
+homepage: https://github.com/galdomedia/citrus-mail
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Nifty Rails gem for nice FreshMail integration
+test_files: []
+