lettr 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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,94 @@
+# Lettr
+Deliver your Emails inside your application through the lettr.de API.
+
+## Usage
+There are currently 5 ways of using this gem.
+
+### Delivery Method
+Just set the Delivery Method of ActionMailer to :lettr, and all Mailings from Action Mailer will be delivered through our API.
+
+    config.action_mailer.delivery_method = :lettr
+
+### Lettr::Mailer
+Let your mailer class inherit from Lettr::Mailer instead of ActionMailer::Base.
+
+    class BookingMailer < Lettr::Mailer
+      FROM = 'intervillas <info@intervillas-florida.com>'
+      def submission_mail(booking)
+        recipients booking.email
+        from FROM
+        subject I18n.t('booking_mailer.ihre_anfrage')
+        body :booking => booking
+      end
+    end
+
+### Manual Mailing
+
+    Lettr.test_mail(:recipient => 'tg@digineo.de', :subject => 'hi', :test => 'some text', :html => 'some html').deliver
+
+### With templates stored at lettr.de
+
+#### and a hash
+Provide a hash containing the variables, that you used in your template.
+
+    Lettr.test_mail(:test => { :variable_1 => 'foo', :variable_2 => 'bar' }).deliver
+
+#### and an object, which responds to :to_nb_hash
+
+    class TestClass
+      def to_nb_hash
+        { :variable_1 => 'foo', :variable_2 => 'bar' }
+      end
+    end
+
+    test_object = TestClass.new
+
+    Lettr.test_mail(:test => test_object ).deliver
+
+#### automagic
+If your provided object does not respond to :to_nb_hash, Lettr will try to automatically serialize it based on the variables you used inside your template.
+Given the following Class Definition:
+
+    class TestClass
+      def variable_1
+        'foo'
+      end
+      def variable_2
+        'bar'
+      end
+    end
+
+And the following Template:
+
+    "{{test.variable_1}} - {{test.variable_2}}"
+
+When you do a request to the Lettr Api
+
+    test_object = TestClass.new
+    Lettr.test_mail(:test => test_object ).deliver
+
+Lettr will invoke the methods :variable_1 and :variable_2 on test_object and serialize their return values for the request.
+So the request will result in the following Mailing:
+
+    "foo - bar"
+
+##### Whitelisting Methods
+For extra Security it is recommended that you extend your Class with the Lettr::Whitelist module.
+It provides a class-level helper method to allow any instance method in your templates.
+
+    class TestClass
+      extend Lettr::Whitelist
+
+      nb_white_list :variable_1
+
+      def variable_1
+        'foo'
+      end
+      def variable_2
+        'bar'
+      end
+    end
+
+In this example the call to :variable_1 will be ok, but the call to :variable_2 will raise an Exception.
+
+Copyright (c) 2010 Digineo GmbH, released under the MIT license

data/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+desc 'Default: run specs.'
+task :default => :specs
+
+#desc 'Test the newsletter_boy plugin.'
+#Rake::TestTask.new(:test) do |t|
+  #t.libs << 'lib'
+  #t.libs << 'test'
+  #t.pattern = 'test/**/*_test.rb'
+  #t.verbose = true
+#end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('specs') do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc 'Generate documentation for the newsletter_boy plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Lettr'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1,3 @@
+if defined? ActionMailer::Base
+  ActionMailer::Base.send(:include, Lettr::ActionMailer)
+end

data/lib/lettr.rb

@@ -0,0 +1,90 @@
+require 'active_support'
+
+module Lettr
+
+  require 'lettr/base'
+  require 'lettr/resource'
+  require 'lettr/recipient'
+  require 'lettr/deliverable'
+  require 'lettr/object_converter'
+  require 'lettr/api_mailing'
+  require 'lettr/delivery'
+  require 'lettr/collection'
+  require 'lettr/rendered_mailing'
+  require 'lettr/whitelist'
+
+  mattr_accessor :host
+  mattr_accessor :attributes
+  mattr_accessor :protocol
+  mattr_accessor :api_mailings
+
+  self.attributes ||= %w{ gender firstname lastname street ccode pcode city }
+  self.protocol ||= 'https'
+  self.host ||= 'www.newsletterboy.de'
+  self.api_mailings = {}
+
+  def self.credentials=(credentials)
+    Base.user = credentials[:user]
+    Base.pass = credentials[:pass]
+  end
+
+  def self.subscribe(recipient)
+    raise 'Object muss über das Attribut :email verfügen.' unless recipient.respond_to? :email
+    rec = Recipient.new recipient.email
+    attributes.each do |attribute|
+      if recipient.respond_to? attribute
+        rec.send("#{attribute}=", recipient.send(attribute))
+      end
+    end
+    rec.approved = true
+    unless rec.save
+      raise rec.errors.join(' ')
+    end
+    rec
+  end
+
+  def self.unsubscribe(email)
+    Recipient.delete_by_email(email)
+  end
+
+  def self.load_api_mailing_or_fail_loud *args
+    identifier = args[0]
+    api_mailing = self.api_mailings[identifier] ||= ApiMailing.find(identifier)
+    options = args[1]
+    api_mailing.delivery_options = options
+    return api_mailing
+  rescue RestClient::ResourceNotFound => e
+    _create_rendered_mail( *args )
+  end
+
+  def self._check_options_for_rendered_mail! options
+    [:subject, :recipient].each do |opt|
+      raise ArgumentError.new ":#{opt} is required" unless options.has_key?( opt )
+    end
+    raise ArgumentError.new ":html or :text is required" unless (options.has_key?( :text ) || options.has_key?( :html ))
+  end
+
+  def self._create_rendered_mail *args
+    _check_options_for_rendered_mail! args[1]
+    mailing = RenderedMailing.find args[0].to_s
+    mailing.attributes = args[1].merge(:identifier => args[0].to_s)
+    mailing
+  rescue RestClient::ResourceNotFound
+    mailing = RenderedMailing.new args[1].merge(:identifier => args[0].to_s)
+    unless mailing.save
+      raise ArgumentError.new mailing.errors.join(' ')
+    end
+    mailing
+  end
+
+  def self.api_mailings
+    @@api_mailings
+  end
+
+  def self.method_missing *args, &block
+    load_api_mailing_or_fail_loud *args
+  rescue RestClient::ResourceNotFound
+    super
+  end
+
+end

data/lib/lettr/action_mailer.rb

@@ -0,0 +1,30 @@
+module Lettr::ActionMailer
+
+  private
+
+  def perform_delivery_lettr mail
+    lettr_request_hashes = []
+    mail.to.each do |recipient|
+      lettr_request_hash = {}
+      lettr_request_hash[:recipient] = recipient
+      lettr_request_hash[:subject] = mail.subject
+      mail.parts.each do |part|
+        case part.content_type
+        when 'text/html'
+          lettr_request_hash[:html] = part.body
+        when 'text/plain'
+          lettr_request_hash[:text] = part.body
+        else
+          lettr_request_hash[:attachments] ||= []
+          lettr_request_hash[:attachments] << part.body
+        end
+      end
+      lettr_request_hashes << lettr_request_hash
+    end
+    identifier = @template
+    lettr_request_hashes.each do |lettr_request_hash|
+      Lettr.send(identifier, lettr_request_hash).deliver
+    end
+
+  end
+end

data/lib/lettr/api_mailing.rb

@@ -0,0 +1,58 @@
+Lettr::ApiMailing = Struct.new(:identifier, :subject, :variables) do
+  include Lettr::Resource
+  include Lettr::ObjectConverter
+  include Lettr::Deliverable
+
+  self.path = 'api_mailings'
+
+  attr_writer :delivery_options
+
+  def initialize attributes={}
+    attributes['api_mailing'].each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+
+  def delivery_options= options
+    @recipient = options.delete(:recipient)
+    @delivery_options = options
+    @delivery_options.stringify_keys!
+  end
+
+  def reload
+    self.send(:initialize, 'api_mailing' => self.class.find(identifier).attributes)
+  end
+
+  def append_used_variables
+    @hash.merge! :variables => variables
+  end
+
+  def group_variables
+    @vars = {}
+    variables.each do |var|
+      methods = var.match(/^(\w+)\..+/)
+      @vars[methods[1]] ||= []
+      @vars[methods[1]] << var
+    end
+  end
+
+  def handle_options
+    # handle options
+    @delivery_options.each do |name, object|
+      case
+      when object.is_a?( Hash )
+        # variablen als @hash übergeben
+        @hash.merge!( name => object )
+      when object.respond_to?( :to_nb_hash )
+        # object liefert variablen
+        @hash.merge!( name => object.to_nb_hash)
+      when object.is_a?( String )
+        @files.merge!( name => File.new(object, 'rb'))
+      else
+        # do magic stuff
+        @hash.merge!(options_to_hash(name))
+      end
+    end
+  end
+
+end

data/lib/lettr/base.rb

@@ -0,0 +1,34 @@
+class Lettr::Base
+  DEFAULT_HEADERS = { :accept => :json }
+
+  cattr_accessor :site, :user, :pass, :content_type
+  attr_reader :client
+
+  def initialize
+    @client = RestClient::Resource.new self.class.site_url, self.class.user, self.class.pass
+  end
+
+  def self.site_url
+    "#{Lettr.protocol}://#{Lettr.host}/"
+  end
+
+  def save object
+    path = object.collection_path
+    payload = object.to_payload
+    payload.merge! :files => object.files if object.respond_to?(:files) && object.files
+    client[path].post(payload, DEFAULT_HEADERS)
+  end
+
+  def destroy object
+    client[object.path].delete DEFAULT_HEADERS
+  end
+
+  def find path
+    ActiveSupport::JSON.decode(client[path].get DEFAULT_HEADERS)
+  end
+
+  def [] path
+    client[path]
+  end
+
+end

data/lib/lettr/collection.rb

@@ -0,0 +1,28 @@
+class Lettr::Collection
+  def initialize collection, context
+    @collection = collection
+    @vars = []
+    @context = context
+  end
+
+  def add_variable var
+    @vars << var
+  end
+
+  def evaluate
+    @collection.each do |element|
+      hash = {}
+      @vars.each do |var|
+        var = var.split('.').last
+        if element.class.respond_to? :is_whitelisted?
+          raise SecurityError, "method #{var} in class #{element.class} not whitelisted" unless element.class.is_whitelisted?(var)
+        end
+        hash[var] = element.send(var)
+      end
+      @context << hash
+    end
+
+  end
+end
+
+

data/lib/lettr/deliverable.rb

@@ -0,0 +1,46 @@
+module Lettr::Deliverable
+
+  def self.included base
+    base.class_eval do
+      attr_accessor :recipient
+    end
+  end
+
+  def recipient?
+    !!@recipient
+  end
+
+  def deliver
+    fail ArgumentError, 'Empfänger nicht übergeben' unless recipient?
+    rec = build_delivery_record
+    rec.save
+    if rec.errors.any?
+      # invalidate cache and retry
+      old_recipient = @hash[:recipient]
+      reload
+      recipient = old_recipient
+      rec = build_delivery_record
+      rec.save
+    end
+    rec
+  end
+
+  def build_delivery_record
+    build_initial_delivery_hash
+    group_variables if respond_to? :group_variables
+    handle_options
+    append_used_variables if respond_to? :append_used_variables
+
+    # perform delivery request
+    rec = Lettr::Delivery.new @hash, @files
+    rec
+  end
+
+  def build_initial_delivery_hash
+    @hash = {}
+    @files = {}
+    @hash[ :recipient ] = recipient
+    @hash[ :api_mailing_id ] = identifier
+  end
+
+end

data/lib/lettr/delivery.rb

@@ -0,0 +1,35 @@
+class Lettr::Delivery
+  include Lettr::Resource
+  attr_reader :files
+
+  def initialize a_hash, files
+    super
+    @params = a_hash
+    @files = files
+  end
+
+  def attributes
+    @params
+  end
+
+  def save
+    unless super
+      dump_json
+    end
+  end
+
+  def dump_json
+    if defined? Rails
+      path = File.join(Rails.root, 'log')
+      File.open(File.join(path, "lettr-delivery-#{Time.now}.json"), 'w') do |f|
+        f.write attributes.to_json
+      end
+    end
+  end
+
+  def collection_path
+    "api_mailings/#{attributes[:api_mailing_id]}/deliveries"
+  end
+end
+
+

data/lib/lettr/mailer.rb

@@ -0,0 +1,7 @@
+class Lettr::Mailer < ActionMailer::Base
+  include Lettr::ActionMailer
+
+  alias perform_delivery_smtp     perform_delivery_lettr
+  alias perform_delivery_sendmail perform_delivery_lettr
+  alias perform_delivery_test     perform_delivery_lettr
+end

data/lib/lettr/object_converter.rb

@@ -0,0 +1,69 @@
+module Lettr::ObjectConverter
+
+  def options_to_hash name
+    hash = {}
+    @collections = {}
+    @vars[name.to_s].each do |var|
+      methods = var.split('.')
+      handle_methods(methods, hash)
+    end
+    evaluate_collections
+    hash
+  end
+
+  def handle_methods methods, hash
+    method_call = methods.last
+    context = hash
+    object_context = @delivery_options
+    methods.each_with_index do |method, index|
+      case method
+        # collection variable
+      when /(\w+)\[([\w\.]+)\]/
+        collection_name = $1
+        variable_name = $2
+        if method == method_call
+          handle_new_collection context, object_context, collection_name, variable_name
+        else
+          if is_collection_variable? methods[index+1]
+            handle_collection_variable( methods[index+1], methods.join('.') )
+            break
+          end
+        end
+
+        # methoden aufruf (letztes element in der kette)
+      when method_call
+        if object_context.class.respond_to? :is_whitelisted?
+          raise SecurityError, "method #{method_call} in class #{object_context.class} not whitelisted" unless object_context.class.is_whitelisted?(method)
+        else
+          warn "no whitelist in class #{object_context.class}"
+        end
+        context[method] = object_context.send(method)
+        # zwischenaufruf
+      else
+        context[method] = {} unless context[method]
+        context = context[method]
+        object_context = index == 0 ? object_context[method] : object_context.send(method)
+      end
+    end
+  end
+
+  def handle_new_collection context, object_context, collection_name, variable_name
+    collection = object_context.send(collection_name)
+    context[collection_name] = []
+    @collections[variable_name] = Lettr::Collection.new collection, context[collection_name]
+  end
+
+  def evaluate_collections
+    @collections.each do |key, collection|
+      collection.evaluate
+    end
+  end
+
+  def is_collection_variable? variable_name
+    @collections.has_key?( variable_name )
+  end
+
+  def handle_collection_variable variable_name, full_variable_name
+    @collections[variable_name].add_variable(full_variable_name)
+  end
+end

data/lib/lettr/recipient.rb

@@ -0,0 +1,22 @@
+Lettr::Recipient = Struct.new( :email, :id, :gender, :firstname, :lastname, :street, :ccode, :pcode, :city, :approved ) do
+  include Lettr::Resource
+  self.path = 'recipients'
+
+  def initialize email
+    super
+    self.email = email
+  end
+
+  def path
+    "#{self.class.path}/#{id}"
+  end
+
+  def collection_path
+    self.class.path
+  end
+
+  def self.delete_by_email email
+    client["#{path}/destroy_by_email"].delete :email => email
+  end
+
+end

data/lib/lettr/rendered_mailing.rb

@@ -0,0 +1,60 @@
+Lettr::RenderedMailing = Struct.new(:identifier, :subject, :html, :text, :files) do
+  include Lettr::Resource
+  include Lettr::Deliverable
+
+  self.path = 'rendered_mailings'
+
+  attr_writer :created_at
+  attr_accessor :recipient
+
+  def initialize attributes={}
+    super
+    if as = attributes.delete('rendered_mailing')
+      as.each do |k, v|
+        if %w{ identifier subject html text files }.include? k
+          send("#{k}=", v)
+        end
+      end
+    end
+    attributes.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+
+  def attributes= attributes
+    attributes.each do |key, value|
+      send("#{key}=", value)
+    end
+  end
+
+  def handle_options
+    attributes.each do |key, value|
+      if key == :files
+        @files.merge! value if value
+      else
+        @hash.merge! key => value
+      end
+    end
+  end
+
+  def to_payload
+    { self.resource_name => attributes_for_create }
+  end
+
+  def path
+    "#{self.class.path}/#{identifier}"
+  end
+
+  def collection_path
+    self.class.path
+  end
+
+  def attributes_for_create
+    as = {}
+    attributes.each do |key, value|
+      as.merge! key => value unless %w{html text files}.include? key.to_s
+    end
+    as
+  end
+
+end

data/lib/lettr/resource.rb

@@ -0,0 +1,68 @@
+module Lettr::Resource
+
+  def self.included base
+    base.extend ClassMethods
+    base.cattr_accessor :path
+    base.send(:attr_accessor, :errors)
+    base.send(:attr_accessor, :id)
+  end
+
+  module ClassMethods
+    def find id
+      new(client.find resource_path(id))
+    end
+
+    def client
+      @client ||= Lettr::Base.new
+    end
+
+    def resource_path id
+      "#{path}/#{id}"
+    end
+  end
+
+  def initialize *args
+    @errors = []
+  end
+
+  def save
+    res = client.save self
+    self.id = ActiveSupport::JSON.decode(res)[resource_name]['id'] unless res.blank?
+    true
+  rescue RestClient::UnprocessableEntity => e
+    self.errors = ActiveSupport::JSON.decode(e.response)
+    false
+  end
+
+  def client
+    self.class.client
+  end
+
+  def to_payload
+    { self.resource_name => self.attributes }
+  end
+
+  def destroy
+    client.destroy self
+  end
+
+  def resource_name
+    self.class.to_s.demodulize.underscore
+  end
+
+  def to_json
+    { resource_name => attributes }.to_json
+  end
+
+  def path
+    "#{self.class.path}/#{id}"
+  end
+
+  def attributes
+    attributes = {}
+    each_pair do |key, value|
+      attributes.merge! key => value
+    end
+    attributes
+  end
+end

data/lib/lettr/whitelist.rb

@@ -0,0 +1,17 @@
+module Lettr::Whitelist
+
+  def self.extended model
+    model.class_inheritable_accessor :lettr_whitelist
+    model.lettr_whitelist ||= []
+  end
+
+  # fügt methoden zur whitelist hinzu
+  # nb_white_list :number, :test, :name
+  def lettr_white_list *args
+    self.lettr_whitelist = args.map(&:to_s)
+  end
+
+  def is_whitelisted? method
+    lettr_whitelist.include? method.to_s
+  end
+end

data/lib/tasks/newsletter_boy.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :newsletter_boy do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: lettr
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Digineo GmbH
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: vcr
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: NewsletterBoy Api
+email: kontakt@digineo.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/lettr/action_mailer.rb
+- lib/lettr/whitelist.rb
+- lib/lettr/collection.rb
+- lib/lettr/resource.rb
+- lib/lettr/object_converter.rb
+- lib/lettr/recipient.rb
+- lib/lettr/mailer.rb
+- lib/lettr/delivery.rb
+- lib/lettr/deliverable.rb
+- lib/lettr/rendered_mailing.rb
+- lib/lettr/base.rb
+- lib/lettr/api_mailing.rb
+- lib/lettr.rb
+- lib/tasks/newsletter_boy.rake
+- README.md
+- Rakefile
+- MIT-LICENSE
+- init.rb
+has_rdoc: true
+homepage: http://digineo.de
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: NewsletterBoy Api
+test_files: []
+