merging-queue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7dae3e92ad88cafbb75132665eae4f3207052388
+  data.tar.gz: b1feaf6f3cc0ec5e0f8bd35e9ae42b3682fe5494
+SHA512:
+  metadata.gz: fd9822d92b529e05891f578404fe341a102eb2a921f933588f51a484ab70b52ea95418ed3c410107cf21dc1fb2031d034c11cfb7abfb676674e9a8d2a7fe26f5
+  data.tar.gz: 8250336736f7c5621b30d69d47f0b8f43dd3657c4c5c251160a0a62ea38091f925e36550a992e4fca9a06c83be296384b168b685d62606a2d0f442401d671fda

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/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 merging-queue.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,146 @@
+# MergingQueue
+
+MergingQueue is a simple gem for grouping tasks by type and time using the ActiveRecord ODM framework and
+background jobs.
+
+This gem is inspired by Streama by Christopher Pappas.
+
+[![Build Status](https://secure.travis-ci.org/digitalplaywright/merging-queue.png)](http://travis-ci.org/digitalplaywright/merging-queue) [![Dependency Status](https://gemnasium.com/digitalplaywright/merging-queue.png)](https://gemnasium.com/digitalplaywright/merging-queue) [![Code Climate](https://codeclimate.com/github/digitalplaywright/merging-queue.png)](https://codeclimate.com/github/digitalplaywright/merging-queue)
+
+
+## Install
+
+    gem install merging-queue
+
+## Usage
+
+### Create migration for queued_tasks and migrate the database (in your Rails project):
+
+```ruby
+rails g merging-queue:migration
+rake db:migrate
+```
+
+### Define Queued Task
+
+Create an QueuedTask model and define the queued_tasks 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 QueuedTask < ActiveRecord::Base
+  include MergingQueue::QueuedTask
+
+  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 QueuedTask Streams 1.0 specification (http://queued_taskstrea.ms)
+
+### Setup Actors
+
+Include the Actor module in a class and override the default followers method.
+
+``` ruby
+class User < ActiveRecord::Base
+  include MergingQueue::Actor
+
+end
+```
+
+
+
+### Publishing QueuedTask
+
+In your controller or background worker:
+
+``` ruby
+current_user.publish_queued_task(: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 QueuedTask
+
+To retrieve all queued_task for an actor
+
+``` ruby
+current_user.queued_tasks
+```
+  
+To retrieve and filter to a particular queued_task type
+
+``` ruby
+current_user.queued_tasks(:verb => 'new_enquiry')
+```
+
+#### Options
+
+Additional options can be required:
+
+``` ruby
+class QueuedTask < ActiveRecord::Base
+  include MergingQueue::QueuedTask
+
+  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 QueuedTask < ActiveRecord::Base
+  include MergingQueue::QueuedTask
+
+  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
+QueuedTask.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/merging-queue.rb

@@ -0,0 +1,14 @@
+require 'rails/generators/named_base'
+
+module MergingQueue
+  # A generator module with QueuedTask table schema.
+  module Generators
+    # A base module 
+    module Base
+      # Get path for migration template
+      def source_root
+        @_merging-queue_source_root ||= File.expand_path(File.join('../merging-queue', generator_name, 'templates'), __FILE__)
+      end
+    end
+  end
+end

data/lib/generators/merging-queue/activity/activity_generator.rb

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

data/lib/generators/merging-queue/activity/templates/activity.rb

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

data/lib/generators/merging-queue/migration/migration_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/queue_collapser'
+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_queued_tasks'
+      # Create migration in project's folder
+      def generate_files
+        migration_template 'migration.rb', "db/migrate/#{name}"
+      end
+    end
+  end
+end

data/lib/generators/merging-queue/migration/templates/migration.rb

@@ -0,0 +1,30 @@
+# Migration responsible for creating a table with queued_tasks
+class CreateQueuedTasks < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :queued_tasks 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 :publish_on
+      t.string :state
+
+      t.timestamps
+    end
+
+    add_index :queued_tasks, [:verb]
+    add_index :queued_tasks, [:actor_id, :actor_type]
+    add_index :queued_tasks, [:act_object_id, :act_object_type]
+    add_index :queued_tasks, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :queued_tasks
+  end
+end

data/lib/merging-queue.rb

@@ -0,0 +1,9 @@
+require 'active_record'
+require 'active_support'
+require 'active_support/core_ext/module/delegation.rb'
+require "merging-queue/version"
+require "merging-queue/actor"
+require "merging-queue/queued_task"
+require "merging-queue/definition"
+require "merging-queue/definition_dsl"
+require "merging-queue/errors"

data/lib/merging-queue/actor.rb

@@ -0,0 +1,54 @@
+module MergingQueue
+  
+  module Actor
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :queued_task_klass
+
+      has_many :queued_tasks,             :class_name => "QueuedTask", :as => :actor
+      has_many :act_object_queued_tasks,  :class_name => "QueuedTask", :as => :act_object
+      has_many :act_target_queued_tasks,  :class_name => "QueuedTask", :as => :act_target
+
+
+    end
+
+    module ClassMethods
+
+      def queued_task_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.publish_queued_task(:enquiry, :act_object => @enquiry, :act_target => @listing)
+    #
+    def publish_queued_task(name, cur_publish_on, options={})
+      cur_publish_on = Time.now + cur_publish_on if cur_publish_on.kind_of?(Fixnum)
+      raise "Expected Time type. Got:" + cur_publish_on.class.name  unless cur_publish_on.kind_of?(Time)
+      queued_task_class.publish(name, cur_publish_on, {:actor => self}.merge(options))
+    end
+
+    def queued_task_class
+      @queued_task_klass ||= queued_task_klass ? queued_task_klass.classify.constantize : ::QueuedTask
+    end
+
+    def queued_merging_tasks(options = {})
+
+      if options.empty?
+        queued_tasks
+      else
+        queued_tasks.where(options)
+      end
+
+    end
+
+  end
+  
+end

data/lib/merging-queue/definition.rb

@@ -0,0 +1,48 @@
+module MergingQueue
+
+  class Definition
+
+    attr_reader :name, :actor, :act_object, :act_target, :grouped_actor, :bond_type, :options
+
+    # @param dsl [MergingQueue::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]       || []
+    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<MergingQueue::Definition>]
+    def self.registered
+      @definitions ||= []
+    end
+
+    def self.find(name)
+      unless definition = registered.find{|definition| definition.name == name.to_sym}
+        raise MergingQueue::InvalidQueuedTask, "Could not find a definition for `#{name}`"
+      else
+        definition
+      end
+    end
+
+
+
+  end
+  
+end

data/lib/merging-queue/definition_dsl.rb

@@ -0,0 +1,48 @@
+require 'active_support'
+
+module MergingQueue
+
+  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,
+          :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
+
+  end
+  
+end

data/lib/merging-queue/errors.rb

@@ -0,0 +1,44 @@
+module MergingQueue
+  
+  class MergingQueueError < StandardError
+  end
+  
+  class InvalidQueuedTask < MergingQueueError
+  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 < MergingQueueError
+    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 < MergingQueueError
+    attr_reader :message
+
+    def initialize message
+      @message = "Invalid Field: #{message}"
+    end
+
+  end
+  
+  class QueuedTaskNotSaved < MergingQueueError
+  end
+  
+  class NoFollowersDefined < MergingQueueError
+  end
+  
+end

data/lib/merging-queue/queued_task.rb

@@ -0,0 +1,237 @@
+module MergingQueue
+  module QueuedTask
+    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?
+
+        ::QueuedTask.where('state = ? AND publish_on <= ?', 'initial', Time.now).distinct(:actor_id).each do |actor_id|
+
+          ::QueuedTask.where('state = ? AND actor_id = ? AND publish_on <= ?', 'initial', actor_id, Time.now).select(:verb).uniq.each do |verb|
+
+            changes_for_actor =  ::QueuedTask.where(:actor_id => actor_id, :state => 'initial', :verb => verb['verb'].to_s)
+
+            begin
+              yield  verb, accumulate_changes(changes_for_actor)
+
+              changes_for_actor.destroy_all
+
+            rescue ActiveRecord::RecordNotFound
+            end
+
+
+          end
+
+
+        end
+      end
+
+      #---- general helpers
+
+      #---- add up all actors, act_objects and act_targets in the search results.
+      #     it does not matter what is where
+      def accumulate_changes(search_result)
+        act_targets    = []
+        act_target_ids = []
+        act_objects    = []
+        act_object_ids = []
+
+        _actor = search_result.first.actor
+
+        search_result.each do |result|
+          result.update_attributes(:state => 'pending')
+
+          act_object = result.act_object
+          act_target = result.act_target
+
+          if act_object != nil && !act_object_ids.include?(act_object.id)
+            act_objects    << act_object
+            act_object_ids << act_object.id
+
+          end
+
+          if act_target != nil && !act_target_ids.include?(act_target.id)
+            act_targets    << act_target
+            act_target_ids << act_target.id
+
+          end
+
+        end
+
+        {:actor => _actor, :act_objects => act_objects, :act_object_ids => act_object_ids,
+         :act_targets => act_targets, :act_target_ids => act_target_ids}
+      end
+
+      # Defines a new QueuedTask2 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 = MergingQueue::DefinitionDSL.new(name)
+        definition.instance_eval(&block)
+        MergingQueue::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 [MergingQueue::QueuedTask2] An QueuedTask instance with data
+      def publish(verb, cur_publish_on, data)
+        new.publish({:verb => verb, :publish_on => cur_publish_on}.merge(data))
+      end
+
+    end
+
+
+
+    # Publishes the queued_task to the receivers
+    #
+    # @param [ Hash ] options The options to publish with.
+    #
+    def publish(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(:publish_on, data[:publish_on])
+      data.delete(:publish_on)
+
+      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 MergingQueue::InvalidData.new(type)
+          else
+            next
+
+          end
+        end
+
+        class_sym = cur_object.class.name.to_sym
+
+        raise MergingQueue::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 MergingQueue::InvalidData.new(group)
+          else
+            next
+
+          end
+        end
+
+        grp_object.each do |cur_obj|
+          raise MergingQueue::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
+
+      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 ||= MergingQueue::Definition.find(verb)
+    end
+
+
+  end
+end

data/lib/merging-queue/version.rb

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

data/merging-queue.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "merging-queue/version"
+
+Gem::Specification.new do |s|
+  s.name        = "merging-queue"
+  s.version     = MergingQueue::VERSION
+  s.authors     = ["Andreas Saebjoernsen"]
+  s.email       = ["andreas.saebjoernsen@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{QueuedTask Streams for rails}
+  s.description = %q{MergingQueue is a simple gem for grouping tasks by type and time using the ActiveRecord ODM framework and background jobs}
+  s.homepage    = 'https://github.com/digitalplaywright/merging-queue'
+
+  s.rubyforge_project = "merging-queue"
+
+  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_queued_tasks.rb

@@ -0,0 +1,30 @@
+# Migration responsible for creating a table with queued_tasks
+class CreateQueuedTasks < ActiveRecord::Migration
+  # Create table
+  def self.up
+    create_table :queued_tasks 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 :publish_on
+      t.string :state
+
+      t.timestamps
+    end
+
+    add_index :queued_tasks, [:verb]
+    add_index :queued_tasks, [:actor_id, :actor_type]
+    add_index :queued_tasks, [:act_object_id, :act_object_type]
+    add_index :queued_tasks, [:act_target_id, :act_target_type]
+  end
+  # Drop table
+  def self.down
+    drop_table :queued_tasks
+  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 :queued_tasks 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,73 @@
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+
+$:.unshift File.expand_path('../../lib/', __FILE__)
+require 'active_support/testing/setup_and_teardown'
+require 'merging-queue'
+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 QueuedTask < ActiveRecord::Base
+  include MergingQueue::QueuedTask
+
+  queued_task :new_enquiry do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    #option       :description
+  end
+
+  queued_task :test_description do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :description
+  end
+
+  queued_task :test_option do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    option       :country
+  end
+
+  queued_task :test_bond_type do
+    actor        :User
+    act_object   :Article
+    act_target   :Volume
+    bond_type    :global
+  end
+
+end
+
+class User < ActiveRecord::Base
+  include MergingQueue::Actor
+
+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 QueuedTaskTest < ActiveSupport::TestCase
+
+  def test_truth
+    assert true
+  end
+
+  def test_register_definition
+
+    @definition = QueuedTask.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?(MergingQueue::Definition)
+
+  end
+
+  def test_publish_new_queued_task
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _queued_task = QueuedTask.publish(:new_enquiry, Time.now, :actor => _user, :act_object => _article, :act_target => _volume)
+
+    assert _queued_task.persisted?
+    #_queued_task.should be_an_instance_of QueuedTask
+
+  end
+
+  def test_description
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _description = "this is a test"
+    _queued_task = QueuedTask.publish(:test_description, Time.now,  :actor => _user, :act_object => _article, :act_target => _volume,
+                                 :description => _description )
+
+    assert _queued_task.description  == _description
+
+  end
+
+  def test_options
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _country = "denmark"
+    _queued_task = QueuedTask.publish(:test_option, Time.now, :actor => _user, :act_object => _article, :act_target => _volume,
+                                 :country => _country )
+
+    assert _queued_task.options[:country]  == _country
+
+  end
+
+  def test_bond_type
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _queued_task = QueuedTask.publish(:test_bond_type, Time.now, :actor => _user, :act_object => _article, :act_target => _volume)
+
+    assert _queued_task.bond_type  == 'global'
+
+  end
+
+  def test_poll_changes
+
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    QueuedTask.publish(:test_bond_type, Time.now, :actor => _user, :act_object => _article, :act_target => _volume)
+
+    assert QueuedTask.all.size > 0
+
+    QueuedTask.poll_for_changes() do |verb, hash|
+      #assert hash[:actor].id == _user.id
+    end
+
+    assert QueuedTask.all.size == 0
+
+
+  end
+
+
+
+
+
+
+end

data/test/unit/actor_test.rb

@@ -0,0 +1,46 @@
+class ActorTest < ActiveSupport::TestCase
+
+
+  def test_publish_queued_task
+
+    _user = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    queued_task = _user.publish_queued_task(:new_enquiry, Time.now, :act_object => _article, :act_target => _volume)
+
+    assert queued_task.persisted?
+
+  end
+
+  def test_retrieves_the_stream_for_an_actor
+    _user    = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _user.publish_queued_task(:new_enquiry, Time.now, :act_object => _article, :act_target => _volume)
+    _user.publish_queued_task(:new_enquiry, Time.now, :act_object => _article, :act_target => _volume)
+
+    assert _user.queued_tasks.size == 2
+
+  end
+
+
+  def test_retrieves_the_stream_for_a_particular_queued_task_type
+    _user = User.create()
+    _article = Article.create()
+    _volume  = Volume.create()
+
+    _user.publish_queued_task(:new_enquiry, Time.now, :act_object => _article, :act_target => _volume)
+    _user.publish_queued_task(:new_enquiry, Time.now, :act_object => _article, :act_target => _volume)
+    _user.publish_queued_task(:test_bond_type, Time.now, :act_object => _article, :act_target => _volume)
+
+    assert _user.queued_merging_tasks(:verb      => 'new_enquiry').size == 2
+    assert _user.queued_merging_tasks(: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
+    MergingQueue::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 = MergingQueue::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     = MergingQueue::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 MergingQueue::Definition.register(definition_dsl).is_a?(MergingQueue::Definition)
+
+  end
+
+  def test_register_invalid_definition
+
+    assert MergingQueue::Definition.register(false)  == false
+
+  end
+
+  def test_return_registered_definitions
+
+    MergingQueue::Definition.register(definition_dsl)
+    assert MergingQueue::Definition.registered.size > 0
+
+  end
+
+  def test_return_definition_by_name
+    assert MergingQueue::Definition.find(:new_enquiry).name == :new_enquiry
+
+  end
+
+  def test_raise_exception_if_invalid_queued_task
+
+    assert_raises(MergingQueue::InvalidQueuedTask){ MergingQueue::Definition.find(:unknown_queued_task) }
+
+  end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: merging-queue
+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: MergingQueue is a simple gem for grouping tasks by type and time using
+  the ActiveRecord ODM framework and background jobs
+email:
+- andreas.saebjoernsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/merging-queue.rb
+- lib/generators/merging-queue/activity/activity_generator.rb
+- lib/generators/merging-queue/activity/templates/activity.rb
+- lib/generators/merging-queue/migration/migration_generator.rb
+- lib/generators/merging-queue/migration/templates/migration.rb
+- lib/merging-queue.rb
+- lib/merging-queue/actor.rb
+- lib/merging-queue/definition.rb
+- lib/merging-queue/definition_dsl.rb
+- lib/merging-queue/errors.rb
+- lib/merging-queue/queued_task.rb
+- lib/merging-queue/version.rb
+- merging-queue.gemspec
+- test/migrations/001_create_queued_tasks.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/merging-queue
+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: merging-queue
+rubygems_version: 2.0.4
+signing_key: 
+specification_version: 4
+summary: QueuedTask Streams for rails
+test_files:
+- test/migrations/001_create_queued_tasks.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: