be_taskable 0.5.0

data/lib/be_taskable/task_runner.rb

@@ -0,0 +1,87 @@
+module BeTaskable
+	class TaskRunner
+
+		attr_reader :task
+
+		def initialize(task)
+			raise ArgumentError, "Invalid task" unless task.is_a?(BeTaskable::Task)
+			@task = task
+		end
+
+		def refresh
+
+			return if task.completed?
+
+			_mark_assignments_as_unconfirmed
+
+			if _relevant?
+				_make_task_relevant
+				_update_task_label
+				_update_assignments
+			else
+				_make_task_irrelevant
+			end
+
+			_delete_unconfirmed_assignments
+		end
+
+		def resolver
+			task.resolver
+		end
+
+		def _mark_assignments_as_unconfirmed
+			_assignments.uncompleted.update_all(confirmed: false)
+		end
+
+		def _delete_unconfirmed_assignments
+			_assignments.uncompleted.unconfirmed.delete_all
+		end
+
+		def _update_task_label
+			task.update_attribute(:label, resolver.label_for_task(task))
+		end
+
+		def _make_task_relevant
+			task.make_relevant if task.can_make_relevant?
+		end
+
+		def _make_task_irrelevant
+			# assignments will be just deleted
+			# no need to update them
+			task.make_irrelevant if task.can_make_irrelevant?
+		end
+
+		def _update_assignments
+			_assignees.each do |assignee|
+				# find the assignment
+				assignment = _assignments.where(assignee_id: assignee.id).last
+
+				unless assignment
+					assignment = _assignments.create(assignee: assignee)
+				end
+				
+				assignment.complete_by = resolver.due_date_for_assignment(assignment)
+				assignment.visible_at = resolver.visible_date_for_assignment(assignment)
+				assignment.label = resolver.label_for_assignment(assignment)
+				assignment.url = resolver.url_for_assignment(assignment)
+				assignment.confirmed = true
+				assignment.save
+			end
+		end
+
+		def _relevant?
+			# if the taskable cannot be found then assume it is not relevant
+			return false unless task.taskable
+			resolver.is_task_relevant?(task)
+		end
+
+		def _assignees
+			resolver.assignees_for_task(task)
+		end
+
+		def _assignments
+			task.assignments
+		end
+
+	end
+end

data/lib/be_taskable/taskable.rb

@@ -0,0 +1,157 @@
+module BeTaskable
+	module Taskable
+
+		def be_taskable(*actions)
+			include InstanceMethods
+
+			has_many :tasks, class_name: '::BeTaskable::Task', dependent: :destroy, as: :taskable
+		end
+
+		def _task_resolver_name_for_action(action)
+			self.name + action.camelize + 'TaskResolver'
+		end
+
+		def _task_resolver_for_action(action)
+			_task_resolver_name_for_action(action).constantize.new
+		end
+
+		module InstanceMethods
+
+			# hook for testing
+			# e.g. expect(instance).to be_taskable
+			def taskable?
+				true
+			end
+
+			# @param {String} action Name of the action
+			# @return {Object} Resolver instance for the given action
+			def task_resolver_for_action(action)
+				self.class._task_resolver_for_action(action)
+			end
+
+			# Create a task and run it
+			# @param {String} action Name of the action
+			# @return {BeTaskable::Task} A task object
+			def create_task_for_action(action)
+				raise(ActiveRecord::RecordNotSaved, "Taskable must be persisted") unless self.persisted?
+
+				task = tasks.create(action: action)
+				
+				if task.persisted?
+					task.on_creation
+					task.refresh
+				else
+					raise "Couldn't create task #{task.errors.full_messages}"
+				end
+
+				task
+			end
+
+			# Finds or Create a task and run it
+			# @param {String} action Name of the action
+			# @return {BeTaskable::Task} A task object
+			def create_or_refresh_task_for_action(action)
+				# if already created use that task
+				task = last_current_task_for_action(action)
+				
+				if !task
+					task = create_task_for_action(action)
+				else
+					task.refresh
+				end
+
+				task
+			end
+
+			# @param {String} action Name of the action
+			# @return {ActiveRecord::Relation}
+			def tasks_for_action(action)
+				tasks.where(action: action)
+			end
+
+			def current_tasks_for_action(action)
+				tasks.where(action: action).current
+			end
+
+			# @param {String} action Name of the action
+			# @return {BeTaskable::Task} Last task for the given action
+			def last_task_for_action(action)
+				tasks_for_action(action).last
+			end
+
+			# @return {BeTaskable::Task} Last current task for the given action
+			def last_current_task_for_action(action)
+				current_tasks_for_action(action).last
+			end
+
+			# @return {Array} All current assignments for this taskable
+			def task_assignments
+				tasks.map(&:assignments).flatten
+			end
+
+			# @return {Array} All current assignments for this action
+			# returns an empty array if it cannot find the task
+			def task_assignments_for_action(action)
+				tasks_for_action(action).map(&:assignments).flatten
+			end
+
+
+			# @param {String} action
+			# @param {Object} assignee
+			# @return {TaskAssignment}
+			# Return nil if it cannot find the task
+			def task_assignment_for(action, assignee)
+				task = last_task_for_action(action)
+				task.assignment_for(assignee) if task
+			end
+
+			def current_task_assignment_for(action, assignee)
+				task = last_current_task_for_action(action)
+				task.assignment_for(assignee) if task
+			end
+
+			# @param {String} action Name of the action
+			# Completes the last task for an action (and all the assignments)
+			def complete_task_for_action(action)
+				task = last_task_for_action(action)
+				return false unless task
+				task.complete!
+			end
+
+			# Completes all task for this action
+			# Only for uncompleted tasks
+			def complete_tasks_for_action(action)
+				ts = current_tasks_for_action(action)
+
+				return false unless ts.any?
+				ts.each do |task|
+					task.complete!
+				end
+				true
+			end
+
+			# @param {String} action Name of the action
+			# @param {Object} assignee
+			# Completes a task assignment
+			def complete_task_for(action, assignee)
+				task = last_task_for_action(action)
+				return false unless task
+				task.complete_by(assignee)
+			end
+
+			# Expire all task for this action
+			# Only for uncompleted tasks
+			def expire_tasks_for_action(action)
+				ts = current_tasks_for_action(action)
+				
+				return false unless ts.any?
+				ts.each do |task|
+					task.expire
+				end
+				true
+			end
+
+		end
+
+	end
+end

data/lib/be_taskable/tasker.rb

@@ -0,0 +1,21 @@
+module BeTaskable
+	module Tasker
+
+		def be_tasker
+			include InstanceMethods
+
+			has_many :task_assignments, class_name: '::BeTaskable::TaskAssignment', dependent: :destroy, foreign_key: :assignee_id
+		end
+
+		module InstanceMethods
+
+			# hook for testing
+			# e.g. expect(instance).to be_tasker
+			def tasker?
+				true
+			end
+
+		end
+
+	end
+end

data/lib/be_taskable.rb

@@ -0,0 +1,28 @@
+require "active_record"
+require "active_record/version"
+# require "action_view"
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module BeTaskable
+	def self.table_name_prefix
+		'be_taskable_'
+	end
+end
+
+require "be_taskable/taskable"
+require "be_taskable/tasker"
+require "be_taskable/task"
+require "be_taskable/task_assignment"
+require "be_taskable/task_resolver"
+require "be_taskable/task_runner"
+
+if defined?(ActiveRecord::Base)
+	ActiveRecord::Base.extend BeTaskable::Taskable
+	ActiveRecord::Base.extend BeTaskable::Tasker
+end
+
+# view helpers
+# if defined?(ActionView::Base)
+#   ActionView::Base.send :include, ActsAsTaggableOn::TagsHelper
+# end

data/lib/generators/be_taskable/migration_generator.rb

@@ -0,0 +1,44 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module BeTaskable
+	class MigrationGenerator < Rails::Generators::Base
+
+		include Rails::Generators::Migration
+
+		desc "Generates migration for BeTaskable Models"
+
+		def self.orm
+			Rails::Generators.options[:rails][:orm]
+		end
+
+		def self.source_root
+			File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+		end
+
+		def self.orm_has_migration?
+			[:active_record].include? orm
+		end
+
+		def self.next_migration_number(dirname)
+			if ActiveRecord::Base.timestamped_migrations
+				migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+				migration_number += 1
+				migration_number.to_s
+			else
+				"%.3d" % (current_migration_number(dirname) + 1)
+			end
+		end
+
+		def create_migration_file
+			if self.class.orm_has_migration?
+				migration_template 'migration.rb', "db/migrate/#{migration_name}"
+			end
+		end
+
+		def migration_name
+			'be_taskable_migration'
+		end
+
+	end
+end

data/lib/generators/be_taskable/resolver_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators'
+
+module BeTaskable
+	class ResolverGenerator < Rails::Generators::Base
+		desc "Create a Task Resolver"
+
+		def self.source_root
+			@source_root ||= File.join(File.dirname(__FILE__), 'templates')
+		end
+
+		argument :taskable, type: :string
+		argument :action_name, type: :string
+
+		def copy_class_file
+			dest = "app/task_resolvers/#{taskable}_#{action_name}_task_resolver.rb"
+			copy_file "resolver.rb.tpl", dest
+			class_name = "#{taskable.camelize}#{action_name.camelize}TaskResolver"
+			gsub_file dest, '{{class_name}}', class_name
+		end
+
+		# def copy_spec_file
+		# 	dest = "spec/services/#{name}_service_spec.rb"
+		# 	copy_file "spec.rb.tpl", dest
+		# 	gsub_file dest, '{{class_name}}', "#{name.camelize}Service"
+		# end
+
+	end
+end

data/lib/generators/be_taskable/templates/active_record/migration.rb

@@ -0,0 +1,35 @@
+class BeTaskableMigration < ActiveRecord::Migration
+	def self.up
+		create_table :be_taskable_tasks do |t|
+			t.string :action
+			t.references :taskable, polymorphic: true
+			t.string :state
+			t.string :label
+			t.datetime :completed_at
+			t.datetime :expired_at
+			t.timestamps
+		end
+		
+		create_table :be_taskable_task_assignments do |t|
+			t.integer :task_id
+			t.references :assignee, polymorphic: true
+			t.string :label
+			t.string :url
+			t.boolean :confirmed
+			t.boolean :enacted
+			t.datetime :visible_at
+			t.datetime :complete_by
+			t.datetime :completed_at
+			t.datetime :expired_at
+			t.timestamps
+		end
+		
+		add_index :be_taskable_tasks, [:taskable_id, :taskable_type]
+		add_index :be_taskable_task_assignments, :task_id
+	end
+	
+	def self.down
+		drop_table :be_taskable_tasks
+		drop_table :be_taskable_task_assignments
+	end
+end

data/lib/generators/be_taskable/templates/resolver.rb.tpl

@@ -0,0 +1,67 @@
+class {{class_name}} < BeTaskable::TaskResolver
+
+	def consensus?(task)
+		# task.any_assignment_done?
+		# if any assignment is completed then return true
+
+		# task.majority_of_assignments_done?
+		# if the majority of assignments are completed then return true
+
+		# task.all_assignments_done?
+		# if all assignments are completed then return true
+			
+		# use task.assignments to calculate consensus manually
+		# false
+	end
+			
+	def is_task_relevant?(task)
+		# get the taskable by calling task.taskable
+		# evaluate if a task is still relevant
+		# e.g. the taskable object is no longer valid
+		# if this method returns false then:
+		#   - the task will be marked as irrelevant 
+		#   - the assignments will be deleted (except the already completed ones)
+		true
+	end
+
+	def assignees_for_task(task)
+		# get the taskable by calling task.taskable
+		[]
+	end
+
+	def due_date_for_assignment(assignment)
+		# get the taskable by calling assignment.taskable
+		nil
+	end
+	
+	def visible_date_for_assignment(assignment)
+		# get the taskable by calling assignment.taskable
+		nil
+	end
+
+	def label_for_task(task)
+		# get the taskable by calling task.taskable
+		""
+	end
+
+	def label_for_assignment(assignment)
+		# get the taskable by calling assignment.taskable
+		""
+	end
+
+	def url_for_assignment(assignment)
+	# get the taskable by calling assignment.taskable
+		""
+	end
+
+	# hooks
+	def on_creation(task)
+	end
+
+	def on_completion(task)
+	end
+
+	def on_expiration(task)
+	end
+
+end