mail-control 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: caaf2a07f4cecd59194d9daf3e6d0e04ee9dedf7
+  data.tar.gz: 4c943c088a90bd54ad7e7f3ae62eaf943325ebce
+SHA512:
+  metadata.gz: 776a0118e140c9692d61cb15b728a04b932697ac4091606fa537ae61eb097792140ebc12c11a6044dc990ecbc80d26d5b37b7d67d2a102ec4b4798bcd2f79663
+  data.tar.gz: 219ff9a4a205aea11a8144ea63164b575405dae75347dfb41275d7dae6a41a123dcd5889ce71446405b97063834500ac9e3710285964a9cfae137c399d1f6344

data/.document

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

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+services: SQLite3
+gemfile:
+  - Gemfile
+rvm:
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+
+## 0.1.0
+
+First version of gem

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+group :development, :test do
+  gem "sqlite3",       :platform => [:ruby, :mswin, :mingw]
+  gem "jdbc-sqlite3",  :platform => :jruby
+end
+
+# Specify your gem's dependencies in mail-control.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Andreas Saebjoernsen
+
+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,145 @@
+# MailControl
+
+MailControl is a simple gem for giving both your app and users control over when, if and how emails are sent out.
+
+This gem is inspired by Streama by Christopher Pappas.
+
+[![Build Status](https://secure.travis-ci.org/digitalplaywright/mail-control.png)](http://travis-ci.org/digitalplaywright/mail-control) [![Dependency Status](https://gemnasium.com/digitalplaywright/mail-control.png)](https://gemnasium.com/digitalplaywright/mail-control) [![Code Climate](https://codeclimate.com/github/digitalplaywright/mail-control.png)](https://codeclimate.com/github/digitalplaywright/mail-control)
+
+
+## Install
+
+    gem install mail-control
+
+## Usage
+
+### Create migration for logged_emails and migrate the database (in your Rails project):
+
+```ruby
+rails g mail-control:migration
+rake db:migrate
+```
+
+### Define Queued Task
+
+Create an LoggedEmail model and define the logged_emails and the fields you would like to cache within the queued_task.
+
+An queued_task consists of an actor, a verb, an act_object, and a target.
+
+``` ruby
+class LoggedEmail < ActiveRecord::Base
+  include MailControl::LoggedEmail
+
+  queued_task :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+  end
+end
+```
+
+The queued_task verb is implied from the queued_task name, in the above example the verb is :new_enquiry
+
+The act_object may be the entity performing the queued_task, or the entity on which the queued_task was performed.
+e.g John(actor) shared a video(act_object)
+
+The target is the act_object that the verb is enacted on.
+e.g. Geraldine(actor) posted a photo(act_object) to her album(target)
+
+This is based on the LoggedEmail Streams 1.0 specification (http://logged_emailstrea.ms)
+
+### Setup Actors
+
+Include the Actor module in a class and override the default followers method.
+
+``` ruby
+class User < ActiveRecord::Base
+  include MailControl::Actor
+
+end
+```
+
+
+
+### Publishing LoggedEmail
+
+In your controller or background worker:
+
+``` ruby
+current_user.send_email(:new_enquiry, :act_object => @enquiry, :target => @listing)
+```
+  
+This will publish the queued_task to the mongoid act_objects returned by the #followers method in the Actor.
+
+
+## Retrieving LoggedEmail
+
+To retrieve all queued_task for an actor
+
+``` ruby
+current_user.logged_emails
+```
+  
+To retrieve and filter to a particular queued_task type
+
+``` ruby
+current_user.logged_emails(:verb => 'new_enquiry')
+```
+
+#### Options
+
+Additional options can be required:
+
+``` ruby
+class LoggedEmail < ActiveRecord::Base
+  include MailControl::LoggedEmail
+
+  queued_task :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :country
+    option       :city
+  end
+end
+```
+
+The option fields are stored using the ActiveRecord 'store' feature.
+
+
+#### Bond type
+
+A verb can have one bond type. This bond type can be used to classify and quickly retrieve
+queued_task feed items that belong to a particular aggregate feed, like e.g the global feed.
+
+``` ruby
+class LoggedEmail < ActiveRecord::Base
+  include MailControl::LoggedEmail
+
+  queued_task :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    bond_type    :global
+  end
+end
+```
+
+### Poll for changes and empty queue
+
+There is a poll changes interface that will group tasks by first actor and then verb. 
+
+```ruby
+LoggedEmail.poll_for_changes() do |verb, hash|
+  #verb is the verb the changes are group by
+  #hash has format: {:actor          => _actor /* actor is the  */, 
+  #                  :act_objects    => act_objects    /* all objects from matching tasks */, 
+  #                  :act_object_ids => act_object_ids /* all object ids from matching tasks */,
+  #                  :act_targets    => act_targets /* all targets from  matching tasks */ , 
+  #                  :act_target_ids => act_target_ids /* all target ids from matching tasks}
+end
+```
+
+
+
+

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb', 'test/unit/*_test.rb']
+end
+

data/lib/generators/mail-control.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/named_base'
+
+module MailControl
+  # A generator module with LoggedEmail table schema.
+  module Generators
+    # A base module 
+    module Base
+      # Get path for migration template
+      def source_root
+        @_mail_control_source_root ||= File.expand_path(File.join('../mail-control', generator_name, 'templates'), __FILE__)
+      end
+    end
+  end
+end

data/lib/generators/mail-control/activity/activity_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/mail-control'
+require 'rails/generators/active_record'
+
+module MailControl
+  module Generators
+    # LoggedEmail generator that creates queued_task model file from template
+    class LoggedEmailGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'logged_email'
+      # Create model in project's folder
+      def generate_files
+        copy_file 'logged_email.rb', "app/models/#{name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/mail-control/activity/templates/logged_email.rb

@@ -0,0 +1,5 @@
+# LoggedEmail model for customisation & custom methods
+class LoggedEmail < ActiveRecord::Base
+  include MailControl::LoggedEmail
+
+end

data/lib/generators/mail-control/migration/migration_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/mail-control'
+require 'rails/generators/active_record'
+
+module LiveStream
+  module Generators
+    # Migration generator that creates migration file from template
+    class MigrationGenerator < ActiveRecord::Generators::Base
+      extend Base
+
+      argument :name, :type => :string, :default => 'create_logged_emails'
+      # Create migration in project's folder
+      def generate_files
+        migration_template 'migration.rb', "db/migrate/#{name}"
+      end
+    end
+  end
+end

data/lib/generators/mail-control/migration/templates/migration.rb

@@ -0,0 +1,33 @@
+# Migration responsible for creating a table with logged_emails
+class CreateLoggedEmails < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :logged_emails do |t|
+      t.belongs_to :actor,      :polymorphic => true
+      t.belongs_to :act_object, :polymorphic => true
+      t.belongs_to :act_target, :polymorphic => true
+
+      t.string  :verb
+      t.string  :description
+      t.string  :options
+      t.string  :bond_type
+
+      t.time :send_after
+      t.time :send_before
+      t.string :state
+
+      t.string :unsubscribe_by
+
+      t.timestamps
+    end
+
+    add_index :logged_emails, [:verb]
+    add_index :logged_emails, [:actor_id, :actor_type]
+    add_index :logged_emails, [:act_object_id, :act_object_type]
+    add_index :logged_emails, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :logged_emails
+  end
+end

data/lib/mail-control.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+require 'active_support'
+require 'active_support/core_ext/module/delegation.rb'
+require "mail-control/version"
+require "mail-control/actor"
+require "mail-control/logged_email"
+require "mail-control/definition"
+require "mail-control/definition_dsl"
+require "mail-control/errors"

data/lib/mail-control/actor.rb

@@ -0,0 +1,58 @@
+module MailControl
+  
+  module Actor
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :queued_task_klass
+
+      has_many :logged_emails,             :class_name => "LoggedEmail", :as => :actor
+      has_many :act_object_logged_emails,  :class_name => "LoggedEmail", :as => :act_object
+      has_many :act_target_logged_emails,  :class_name => "LoggedEmail", :as => :act_target
+
+
+    end
+
+    module ClassMethods
+
+      def mail_control_class(klass)
+        self.queued_task_klass = klass.to_s
+      end
+
+    end
+
+
+    # Publishes the queued_task to the receivers
+    #
+    # @param [ Hash ] options The options to publish with.
+    #
+    # @example publish an queued_task with a act_object and act_target
+    #   current_user.send_email(:enquiry, :act_object => @enquiry, :act_target => @listing)
+    #
+    def send_email(name, options={})
+      options[:send_after]  = Time.now + options[:send_after]  if options[:send_after].kind_of?(Fixnum)
+      options[:send_before] = Time.now + options[:send_before] if options[:send_before].kind_of?(Fixnum)
+
+      raise "Expected Time type. Got:" + options[:send_after].class.name   unless options[:send_after].kind_of?(Time)
+      raise "Expected Time type. Got:" + options[:send_before].class.name  unless options[:send_before].kind_of?(Time)
+
+      mail_control_class.send_email(name, {:actor => self}.merge(options))
+    end
+
+    def mail_control_class
+      @queued_task_klass ||= queued_task_klass ? queued_task_klass.classify.constantize : ::LoggedEmail
+    end
+
+    def actor_logged_emails(options = {})
+
+      if options.empty?
+        logged_emails
+      else
+        logged_emails.where(options)
+      end
+
+    end
+
+  end
+  
+end

data/lib/mail-control/definition.rb

@@ -0,0 +1,52 @@
+module MailControl
+
+  class Definition
+
+    attr_reader :name, :actor, :act_object, :act_target, :grouped_actor, :bond_type, :options
+    attr_reader :unsubscribe_by
+
+
+    # @param dsl [MailControl::DefinitionDSL] A DSL act_object
+    def initialize(definition)
+      @name             = definition[:name]
+      @actor            = definition[:actor]         || nil
+      @act_object       = definition[:act_object]    || nil
+      @act_target       = definition[:act_target]    || nil
+      @grouped_actor    = definition[:grouped_actor] || nil
+      @bond_type        = definition[:bond_type]     || nil
+      @options          = definition[:options]       || []
+      @unsubscribe_by = definition[:unsubscribe_by] || nil
+
+    end
+
+    #
+    # Registers a new definition
+    #
+    # @param definition [Definition] The definition to register
+    # @return [Definition] Returns the registered definition
+    def self.register(definition)
+      return false unless definition.is_a? DefinitionDSL
+      definition = new(definition)
+      self.registered << definition
+      return definition || false
+    end
+
+    # List of registered definitions
+    # @return [Array<MailControl::Definition>]
+    def self.registered
+      @definitions ||= []
+    end
+
+    def self.find(name)
+      unless definition = registered.find{|definition| definition.name == name.to_sym}
+        raise MailControl::InvalidLoggedEmail, "Could not find a definition for `#{name}`"
+      else
+        definition
+      end
+    end
+
+
+
+  end
+  
+end

data/lib/mail-control/definition_dsl.rb

@@ -0,0 +1,49 @@
+require 'active_support'
+
+module MailControl
+
+  class DefinitionDSL
+
+    attr_reader :attributes
+
+    def initialize(name)
+      @attributes = {
+          :name             => name.to_sym,
+          :actor            => nil,
+          :act_object       => nil,
+          :act_target       => nil,
+          :grouped_actor    => nil,
+          :reverses         => nil,
+          :bond_type        => nil,
+          :unsubscribe_by => nil,
+          :options          => nil
+      }
+    end
+
+    def add_option(option)
+      @attributes[:options] ||= []
+
+      @attributes[:options] << option
+    end
+
+    def option(text)
+      add_option( text )
+    end
+
+    delegate :[], :to => :@attributes
+
+    def self.data_methods(*args)
+      args.each do |method|
+        define_method method do |*args|
+
+          @attributes[method] = args[0]
+
+        end
+      end
+    end
+
+    data_methods :actor, :act_object, :act_target, :grouped_actor, :bond_type, :unsubscribe_by
+
+  end
+  
+end

data/lib/mail-control/errors.rb

@@ -0,0 +1,44 @@
+module MailControl
+  
+  class MailControlError < StandardError
+  end
+  
+  class InvalidLoggedEmail < MailControlError
+  end
+  
+  # This error is raised when an act_object isn't defined
+  # as an actor, act_object or act_target
+  #
+  # Example:
+  #
+  # <tt>InvalidField.new('field_name')</tt>
+  class InvalidData < MailControlError
+    attr_reader :message
+
+    def initialize message
+      @message = "Invalid Data: #{message}"
+    end
+
+  end
+  
+  # This error is raised when trying to store a field that doesn't exist
+  #
+  # Example:
+  #
+  # <tt>InvalidField.new('field_name')</tt>
+  class InvalidField < MailControlError
+    attr_reader :message
+
+    def initialize message
+      @message = "Invalid Field: #{message}"
+    end
+
+  end
+  
+  class LoggedEmailNotSaved < MailControlError
+  end
+  
+  class NoFollowersDefined < MailControlError
+  end
+  
+end

data/lib/mail-control/logged_email.rb

@@ -0,0 +1,216 @@
+module MailControl
+  module LoggedEmail
+    extend ActiveSupport::Concern
+
+    included do
+
+      store :options
+
+      belongs_to :actor,      :polymorphic => true
+      belongs_to :act_object, :polymorphic => true
+      belongs_to :act_target, :polymorphic => true
+
+      validates_presence_of :actor_id, :actor_type, :verb
+    end
+
+    module ClassMethods
+
+      def poll_for_changes()
+        #if block_given?
+
+        ::LoggedEmail.where('state = ? AND send_after <= ?', 'initial', Time.now).select(:act_target_id).uniq.each do |cur_target|
+          target_id =  cur_target['act_target_id']
+
+          ::LoggedEmail.where('state = ? AND act_target_id = ? AND send_after <= ?', 'initial', target_id, Time.now).select(:verb).uniq.each do |verb|
+
+            changes_for_target =  ::LoggedEmail.where(:act_target_id => target_id, :state => 'initial', :verb => verb['verb'].to_s)
+
+            yield  verb, changes_for_target
+
+            changes_for_target.each do |cft|
+              cft.update_attributes(:state => 'complete')
+            end
+
+
+
+          end
+
+
+        end
+      end
+
+
+      # Defines a new LoggedEmail2 type and registers a definition
+      #
+      # @param [ String ] name The name of the queued_task
+      #
+      # @example Define a new queued_task
+      #   queued_task(:enquiry) do
+      #     actor :user, :cache => [:full_name]
+      #     act_object :enquiry, :cache => [:subject]
+      #     act_target :listing, :cache => [:title]
+      #   end
+      #
+      # @return [Definition] Returns the registered definition
+      def queued_task(name, &block)
+        definition = MailControl::DefinitionDSL.new(name)
+        definition.instance_eval(&block)
+        MailControl::Definition.register(definition)
+      end
+
+      # Publishes an queued_task using an queued_task name and data
+      #
+      # @param [ String ] verb The verb of the queued_task
+      # @param [ Hash ] data The data to initialize the queued_task with.
+      #
+      # @return [MailControl::LoggedEmail2] An LoggedEmail instance with data
+      def send_email(verb, data)
+        new.send_email({:verb => verb}.merge(data))
+      end
+
+    end
+
+
+
+    # Publishes the queued_task to the receivers
+    #
+    # @param [ Hash ] options The options to send_email with.
+    #
+    def send_email(data = {})
+      assign_properties(data)
+
+      self
+    end
+
+
+    def refresh_data
+      save(:validate => false)
+    end
+
+    protected
+
+    def assign_properties(data = {})
+
+      self.verb      = data.delete(:verb)
+
+
+      write_attribute(:send_after, data[:send_after])
+      data.delete(:send_after)
+
+      write_attribute(:send_before, data[:send_before])
+      data.delete(:send_before)
+
+      self.state = 'initial'
+
+      [:actor, :act_object, :act_target].each do |type|
+
+        cur_object = data[type]
+
+        unless cur_object
+          if definition.send(type.to_sym)
+            raise verb.to_json
+            #raise MailControl::InvalidData.new(type)
+          else
+            next
+
+          end
+        end
+
+        class_sym = cur_object.class.name.to_sym
+
+        raise MailControl::InvalidData.new(class_sym) unless definition.send(type) == class_sym
+
+        case type
+          when :actor
+            self.actor = cur_object
+          when :act_object
+            self.act_object = cur_object
+          when :act_target
+            self.act_target = cur_object
+          else
+            raise "unknown type"
+        end
+
+        data.delete(type)
+
+      end
+
+      [:grouped_actor].each do |group|
+
+
+        grp_object = data[group]
+
+        if grp_object == nil
+          if definition.send(group.to_sym)
+            raise verb.to_json
+            #raise MailControl::InvalidData.new(group)
+          else
+            next
+
+          end
+        end
+
+        grp_object.each do |cur_obj|
+          raise MailControl::InvalidData.new(class_sym) unless definition.send(group) == cur_obj.class.name.to_sym
+
+          self.grouped_actors << cur_obj
+
+        end
+
+        data.delete(group)
+
+      end
+
+      cur_bond_type = definition.send(:bond_type)
+
+      if cur_bond_type
+        write_attribute( :bond_type, cur_bond_type.to_s )
+      end
+
+      if definition.send(:unsubscribe_by)
+        write_attribute(:unsubscribe_by, definition.send(:unsubscribe_by))
+      else
+        raise "definition must define unsubscribe_by option"
+      end
+
+      if self.act_target.is_unsubscribed_to?(self)
+        self.state = 'unsubscribed'
+      end
+
+      def_options = definition.send(:options)
+      def_options.each do |cur_option|
+        cur_object = data[cur_option]
+
+        if cur_object
+
+          if cur_option == :description
+            self.description = cur_object
+          else
+            options[cur_option] = cur_object
+          end
+          data.delete(cur_option)
+
+        else
+          #all options defined must be used
+          raise Streama::InvalidData.new(cur_object[0])
+        end
+      end
+
+      if data.size > 0
+        raise "unexpected arguments: " + data.to_json
+      end
+
+
+
+      self.save
+
+
+    end
+
+    def definition
+      @definition ||= MailControl::Definition.find(verb)
+    end
+
+
+  end
+end

data/lib/mail-control/version.rb

@@ -0,0 +1,3 @@
+module MailControl
+  VERSION = "0.1.0"
+end

data/mail-control.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mail-control/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mail-control"
+  s.version     = MailControl::VERSION
+  s.authors     = ["Andreas Saebjoernsen"]
+  s.email       = ["andreas.saebjoernsen@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{LoggedEmail Streams for rails}
+  s.description = %q{MailControl is a simple gem for giving both your app and users control over when, if and how emails are sent out.}
+  s.homepage    = 'https://github.com/digitalplaywright/mail-control'
+
+  s.rubyforge_project = "mail-control"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency 'activerecord', '>= 3'
+  s.add_dependency 'activesupport', '>= 3'
+  s.add_dependency 'actionpack', '>= 3'
+  s.add_development_dependency 'rake'
+
+end

data/test/migrations/001_create_logged_emails.rb

@@ -0,0 +1,33 @@
+# Migration responsible for creating a table with logged_emails
+class CreateLoggedEmails < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :logged_emails do |t|
+      t.belongs_to :actor,      :polymorphic => true
+      t.belongs_to :act_object, :polymorphic => true
+      t.belongs_to :act_target, :polymorphic => true
+
+      t.string  :verb
+      t.string  :description
+      t.string  :options
+      t.string  :bond_type
+
+      t.time :send_after
+      t.time :send_before
+      t.string :state
+
+      t.string :unsubscribe_by
+
+      t.timestamps
+    end
+
+    add_index :logged_emails, [:verb]
+    add_index :logged_emails, [:actor_id, :actor_type]
+    add_index :logged_emails, [:act_object_id, :act_object_type]
+    add_index :logged_emails, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :logged_emails
+  end
+end

data/test/migrations/002_create_articles.rb

@@ -0,0 +1,11 @@
+class CreateArticles < ActiveRecord::Migration
+  def self.up
+    puts "creating"
+    create_table :articles do |t|
+      t.string :name
+      t.boolean :published
+      t.belongs_to :user
+      t.timestamps
+    end
+  end
+end

data/test/migrations/003_create_users.rb

@@ -0,0 +1,8 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end

data/test/migrations/004_add_nonstandard_to_activities.rb

@@ -0,0 +1,7 @@
+class AddNonstandardToActivities < ActiveRecord::Migration
+  def change
+    change_table :logged_emails do |t|
+      t.string :nonstandard
+    end
+  end
+end

data/test/migrations/005_create_volumes.rb

@@ -0,0 +1,9 @@
+class CreateVolumes < ActiveRecord::Migration
+  def self.up
+    puts "creating"
+    create_table :volumes do |t|
+      t.belongs_to :user
+      t.timestamps
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require 'active_support/testing/setup_and_teardown'
+require 'mail-control'
+require 'minitest/autorun'
+
+#LiveStream.config # touch config to load ORM, needed in some separate tests
+
+require 'active_record'
+require 'active_record/connection_adapters/sqlite3_adapter'
+
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  #fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end
+
+class LoggedEmail < ActiveRecord::Base
+  include MailControl::LoggedEmail
+
+  queued_task :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :User
+    #option       :description
+    unsubscribe_by :option_1
+  end
+
+  queued_task :test_description do
+    actor        :User
+    act_object   :Article
+    act_target   :User
+    option       :description
+    unsubscribe_by :option_1
+  end
+
+  queued_task :test_option do
+    actor        :User
+    act_object   :Article
+    act_target   :User
+    option       :country
+    unsubscribe_by :option_1
+  end
+
+  queued_task :test_bond_type do
+    actor        :User
+    act_object   :Article
+    act_target   :User
+    bond_type    :global
+    unsubscribe_by :option_1
+  end
+
+end
+
+class User < ActiveRecord::Base
+  include MailControl::Actor
+
+  def is_unsubscribed_to?(_logged_email)
+    _logged_email.unsubscribe_by == 'i_am_unsubscribed'
+  end
+
+end
+
+class Article < ActiveRecord::Base
+
+end
+
+class Volume < ActiveRecord::Base
+
+end
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Migrator.migrate(File.expand_path('../migrations', __FILE__))

data/test/unit/activity_test.rb

@@ -0,0 +1,92 @@
+class LoggedEmailTest < ActiveSupport::TestCase
+
+  def test_truth
+    assert true
+  end
+
+  def test_register_definition
+
+    @definition = LoggedEmail.queued_task(:test_queued_task) do
+      actor :user, :cache => [:full_name]
+      act_object :listing, :cache => [:title, :full_address]
+      act_target :listing, :cache => [:title]
+    end
+
+    assert @definition.is_a?(MailControl::Definition)
+
+  end
+
+  def test_publish_new_queued_task
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _queued_task = LoggedEmail.send_email(:new_enquiry, :send_after => Time.now, :send_before => Time.now + 1.hour,  :actor => _user, :act_object => _article, :act_target => _user_t )
+
+    assert _queued_task.persisted?
+    #_queued_task.should be_an_instance_of LoggedEmail
+
+  end
+
+  def test_description
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _description = "this is a test"
+    _queued_task = LoggedEmail.send_email(:test_description, :send_after => Time.now, :send_before => Time.now + 1.hour,   :actor => _user, :act_object => _article, :act_target => _user_t ,
+                                 :description => _description )
+
+    assert _queued_task.description  == _description
+
+  end
+
+  def test_options
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _country = "denmark"
+    _queued_task = LoggedEmail.send_email(:test_option, :send_after => Time.now, :send_before => Time.now + 1.hour, :actor => _user, :act_object => _article, :act_target => _user_t ,
+                                 :country => _country )
+
+    assert _queued_task.options[:country]  == _country
+
+  end
+
+  def test_bond_type
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _queued_task = LoggedEmail.send_email(:test_bond_type, :send_after => Time.now, :send_before => Time.now + 1.hour, :actor => _user, :act_object => _article, :act_target => _user_t )
+
+    assert _queued_task.bond_type  == 'global'
+
+  end
+
+  def test_poll_changes
+
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _activity = LoggedEmail.send_email(:test_bond_type, :send_after => Time.now - 1.hour, :send_before => Time.now + 1.hour, :actor => _user, :act_object => _article, :act_target => _user_t )
+
+    assert LoggedEmail.all.size > 0
+
+
+    LoggedEmail.poll_for_changes() do |verb, hash|
+      #assert hash[:actor].id == _user.id
+    end
+
+    assert LoggedEmail.where('state = ? AND act_target_id = ?', 'initial', _user_t.id).size == 0
+
+  end
+
+
+
+
+
+
+end

data/test/unit/actor_test.rb

@@ -0,0 +1,46 @@
+class ActorTest < ActiveSupport::TestCase
+
+
+  def test_send_email
+
+    _user = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    queued_task = _user.send_email(:new_enquiry,  :send_after => Time.now, :send_before => Time.now + 1.hour, :act_object => _article, :act_target => _user_t  )
+
+    assert queued_task.persisted?
+
+  end
+
+  def test_retrieves_the_stream_for_an_actor
+    _user    = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _user.send_email(:new_enquiry, :send_after => Time.now, :send_before => Time.now + 1.hour,  :act_object => _article, :act_target => _user_t  )
+    _user.send_email(:new_enquiry,  :send_after => Time.now, :send_before => Time.now + 1.hour, :act_object => _article, :act_target => _user_t  )
+
+    assert _user.logged_emails.size == 2
+
+  end
+
+
+  def test_retrieves_the_stream_for_a_particular_queued_task_type
+    _user = User.create()
+    _article = Article.create()
+    _user_t  = User.create()
+
+    _user.send_email(:new_enquiry, :send_after => Time.now, :send_before => Time.now + 1.hour,  :act_object => _article, :act_target => _user_t  )
+    _user.send_email(:new_enquiry,  :send_after => Time.now, :send_before => Time.now + 1.hour, :act_object => _article, :act_target => _user_t  )
+    _user.send_email(:test_bond_type,  :send_after => Time.now, :send_before => Time.now + 1.hour, :act_object => _article, :act_target => _user_t  )
+
+    assert _user.actor_logged_emails(:verb      => 'new_enquiry').size == 2
+    assert _user.actor_logged_emails(:bond_type => 'global').size == 1
+
+  end
+
+
+
+
+end

data/test/unit/definition_dsl_test.rb

@@ -0,0 +1,29 @@
+class DefinitionDslTest < ActiveSupport::TestCase
+
+  def definition_dsl
+    MailControl::DefinitionDSL.new(:new_enquiry)
+  end
+
+  def test_initializes_with_name
+    assert definition_dsl.attributes[:name] == :new_enquiry
+  end
+
+  def test_adds_an_actor_to_the_definition
+    dsl = definition_dsl
+    dsl.actor(:User)
+    assert dsl.attributes[:actor] == :User
+  end
+
+  def test_adds_an_act_object_to_the_definition
+    dsl = definition_dsl
+    dsl.act_object(:Article)
+    assert dsl.attributes[:act_object] == :Article
+  end
+
+  def test_adds_a_act_target_to_the_definition
+    dsl = definition_dsl
+    dsl.act_target(:Volume)
+    assert dsl.attributes[:act_target] == :Volume
+  end
+
+end

data/test/unit/definition_test.rb

@@ -0,0 +1,51 @@
+class DefinitionTest < ActiveSupport::TestCase
+
+  def definition_dsl
+    dsl = MailControl::DefinitionDSL.new(:new_enquiry)
+    dsl.actor(:User)
+    dsl.act_object(:Article)
+    dsl.act_target(:Volume)
+    dsl
+  end
+
+  def test_initialization
+    _definition_dsl = definition_dsl
+    _definition     = MailControl::Definition.new(_definition_dsl)
+
+    assert _definition.actor      == :User
+    assert _definition.act_object == :Article
+    assert _definition.act_target == :Volume
+
+  end
+
+  def test_register_definition_and_return_new_definition
+
+    assert MailControl::Definition.register(definition_dsl).is_a?(MailControl::Definition)
+
+  end
+
+  def test_register_invalid_definition
+
+    assert MailControl::Definition.register(false)  == false
+
+  end
+
+  def test_return_registered_definitions
+
+    MailControl::Definition.register(definition_dsl)
+    assert MailControl::Definition.registered.size > 0
+
+  end
+
+  def test_return_definition_by_name
+    assert MailControl::Definition.find(:new_enquiry).name == :new_enquiry
+
+  end
+
+  def test_raise_exception_if_invalid_queued_task
+
+    assert_raises(MailControl::InvalidLoggedEmail){ MailControl::Definition.find(:unknown_queued_task) }
+
+  end
+
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: mail-control
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andreas Saebjoernsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MailControl is a simple gem for giving both your app and users control
+  over when, if and how emails are sent out.
+email:
+- andreas.saebjoernsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/mail-control.rb
+- lib/generators/mail-control/activity/activity_generator.rb
+- lib/generators/mail-control/activity/templates/logged_email.rb
+- lib/generators/mail-control/migration/migration_generator.rb
+- lib/generators/mail-control/migration/templates/migration.rb
+- lib/mail-control.rb
+- lib/mail-control/actor.rb
+- lib/mail-control/definition.rb
+- lib/mail-control/definition_dsl.rb
+- lib/mail-control/errors.rb
+- lib/mail-control/logged_email.rb
+- lib/mail-control/version.rb
+- mail-control.gemspec
+- test/migrations/001_create_logged_emails.rb
+- test/migrations/002_create_articles.rb
+- test/migrations/003_create_users.rb
+- test/migrations/004_add_nonstandard_to_activities.rb
+- test/migrations/005_create_volumes.rb
+- test/test_helper.rb
+- test/unit/activity_test.rb
+- test/unit/actor_test.rb
+- test/unit/definition_dsl_test.rb
+- test/unit/definition_test.rb
+homepage: https://github.com/digitalplaywright/mail-control
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: mail-control
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: LoggedEmail Streams for rails
+test_files:
+- test/migrations/001_create_logged_emails.rb
+- test/migrations/002_create_articles.rb
+- test/migrations/003_create_users.rb
+- test/migrations/004_add_nonstandard_to_activities.rb
+- test/migrations/005_create_volumes.rb
+- test/test_helper.rb
+- test/unit/activity_test.rb
+- test/unit/actor_test.rb
+- test/unit/definition_dsl_test.rb
+- test/unit/definition_test.rb
+has_rdoc: