@@ -1,15 +1,8 @@ --- vendor/plugins/presenter: squashed: true - url: git://github.com/assaf/presenter.git type: git + url: git://github.com/assaf/presenter.git revision: 5d40ec18f66f6d0b7e79e054f59e26d3eb622a04 branch: master remote: braid/vendor/plugins/presenter -vendor/plugins/activerecord_symbolize: - squashed: true - url: http://github.com/zargony/activerecord_symbolize.git - type: git - revision: 2a73ef9028b9dab8c4c703174dca53ffba9d10f4 - branch: master - remote: braid/vendor/plugins/activerecord-symbolize .braids @@ -70,8 +70,10 @@ protected end end end - I18n.locale = @authenticated && @authenticated.locale - Time.zone = @authenticated && @authenticated.timezone + if @authenticated + I18n.locale = @authenticated.locale.to_sym if @authenticated.locale + Time.zone = @authenticated.timezone + end end end app/controllers/application_controller.rb @@ -27,8 +27,8 @@ module TaskHelper case task.status when 'ready', 'active' vitals = [ 'Created ' + abbr_time(task.created_at, relative_time(task.created_at), :class=>'published') ] - vitals.first << ' by ' + link_to_person(task.creator, :rel=>:creator) if task.creator - vitals << 'assigned to ' + link_to_person(task.owner, :rel=>:owner) if task.owner + vitals.first << ' by ' + link_to_person(task.creator, :rel=>'creator') if task.creator + vitals << 'assigned to ' + link_to_person(task.owner, :rel=>'owner') if task.owner vitals << 'high priority' if task.high_priority? vitals << 'due ' + abbr_date(task.due_on, relative_date(task.due_on)) if task.due_on vitals.to_sentence @@ -36,7 +36,7 @@ module TaskHelper when 'suspended' return "Suspended" when 'completed' - "Completed on #{task.updated_at.to_date.to_s(:long)} by #{link_to_person task.owner, :rel=>:owner}" + "Completed on #{task.updated_at.to_date.to_s(:long)} by #{link_to_person task.owner, :rel=>'owner'}" when 'cancelled' "Cancelled on #{task.updated_at.to_date.to_s(:long)}" end app/helpers/task_helper.rb @@ -38,7 +38,6 @@ class Activity < ActiveRecord::Base belongs_to :person validates_presence_of :person - symbolize :name validates_presence_of :name attr_readable :name, :person, :created_at app/models/activity.rb @@ -78,7 +78,6 @@ class Person < ActiveRecord::Base attr_accessible :identity, :fullname, :email, :locale, :timezone, :password - symbolize :locale # Returns an identifier suitable for use with Person.resolve. def to_param @@ -156,8 +155,8 @@ class Person < ActiveRecord::Base def new(attributes = {}, &block) Task.new attributes do |task| yield task if block_given? - task.stakeholders.build :role=>:creator, :person=>proxy_owner if task.in_role(:creator).empty? - task.stakeholders.build :role=>:supervisor, :person=>proxy_owner if task.in_role(:supervisor).empty? + task.stakeholders.build :role=>'creator', :person=>proxy_owner if task.in_role('creator').empty? + task.stakeholders.build :role=>'supervisor', :person=>proxy_owner if task.in_role('supervisor').empty? end end @@ -175,7 +174,7 @@ class Person < ActiveRecord::Base # Use this to find a task and update it on behalf of this person. For example: # task = owner.tasks.find(task_id) - # task.update_attributes :status=>:completed + # task.update_attributes :status=>'completed' def find(*args) super.tap do |found| Array(found).each do |task| @@ -195,32 +194,32 @@ class Person < ActiveRecord::Base # Returns true if this person can delegate the task. Offered to current owner and supervisor. def can_delegate?(task, person = nil) - (task.owner == self || task.in_role?(:supervisor, self)) && (person.nil? || task.can_own?(person)) + (task.owner == self || task.in_role?('supervisor', self)) && (person.nil? || task.can_own?(person)) end # Returns true if this person can suspend the task. def can_suspend?(task) - task.available? && task.in_role?(:supervisor, self) + task.available? && task.in_role?('supervisor', self) end # Returns true if this person can resume the task. def can_resume?(task) - task.suspended? && task.in_role?(:supervisor, self) + task.suspended? && task.in_role?('supervisor', self) end # Returns true if this person can cancel the task. def can_cancel?(task) - !task.completed? && !task.cancelled? && task.in_role?(:supervisor, self) + !task.completed? && !task.cancelled? && task.in_role?('supervisor', self) end # Returns true if this person can complete the task. Must be owner of an active task. def can_complete?(task) - task.active? && task.in_role?(:owner, self) + task.active? && task.in_role?('owner', self) end # Returns true if this person can change various task attributes. def can_change?(task) - !task.completed? && !task.cancelled? && task.in_role?(:supervisor, self) + !task.completed? && !task.cancelled? && task.in_role?('supervisor', self) end end app/models/person.rb @@ -35,7 +35,7 @@ class Stakeholder < ActiveRecord::Base # A task will only have one stakeholder in this role: # * creator -- Person who created the task, specified at creation. # * owner -- Person who currently owns (performs) the task. - SINGULAR_ROLES = [:creator, :owner] + SINGULAR_ROLES = ['creator', 'owner'] # A task will have multiple stakeholders in this role: # * potential_owner -- Person who is allowed to claim (become owner of) the task. @@ -43,7 +43,7 @@ class Stakeholder < ActiveRecord::Base # * past_owner -- Previous but no longer owner of the task. # * supervisor -- Supervisors are allowed to modify the task, change its status, etc. # * observer -- Watches and receives notifications about the task. - PLURAL_ROLES = [:potential_owner, :excluded_owner, :past_owner, :observer, :supervisor] + PLURAL_ROLES = ['potential_owner', 'excluded_owner', 'past_owner', 'observer', 'supervisor'] ROLES = SINGULAR_ROLES + PLURAL_ROLES @@ -57,8 +57,12 @@ class Stakeholder < ActiveRecord::Base belongs_to :person validates_presence_of :person - symbolize :role, :in=>ROLES + validates_inclusion_of :role, :in=>ROLES validates_presence_of :role validates_uniqueness_of :role, :scope=>[:task_id, :person_id] + def to_hash + { :person=>person.to_param, :role=>role } + end + end app/models/stakeholder.rb @@ -46,7 +46,7 @@ class Task < ActiveRecord::Base def initialize(*args, &block) super - self[:status] = :available + self[:status] = 'available' self[:priority] ||= DEFAULT_PRIORITY self[:access_key] = ActiveSupport::SecureRandom.hex(16) end @@ -132,26 +132,26 @@ class Task < ActiveRecord::Base :before_add=>:stakeholders_before_add, :before_remove=>:stakeholders_before_remove def stakeholders_with_supervisor_access=(list) - raise ActiveRecord::RecordInvalid, self unless new_record? || in_role?(:supervisor, modified_by) + raise ActiveRecord::RecordInvalid, self unless new_record? || in_role?('supervisor', modified_by) self.stakeholders_without_supervisor_access = list end alias_method_chain :stakeholders=, :supervisor_access # Return all people associate with the specified role. For example: - # task.in_role(:observer) + # task.in_role('observer') def in_role(role) stakeholders.select { |sh| sh.role == role }.map(&:person) end # Return all people associated with the specified roles. For example: - # task.in_roles(:owner, :potential) + # task.in_roles('owner', 'potential') def in_roles(*roles) stakeholders.select { |sh| roles.include?(sh.role) }.map(&:person).uniq end # Return true if a person is associated with this task in a particular role. For example: - # task.in_role?(:owner, john) - # task.in_role?(:owner, "john.smith") + # task.in_role?('owner', john) + # task.in_role?('owner', "john.smith") def in_role?(role, identity) return false unless identity person = Person.identify(identity) @@ -159,41 +159,41 @@ class Task < ActiveRecord::Base end def owner - in_role(:owner).first + in_role('owner').first end def owner=(person) person = Person.identify(person) if person unless person == owner - stakeholders.delete stakeholders.select { |sh| sh.role == :owner } - stakeholders.build :person=>person, :role=>:owner if person + stakeholders.delete stakeholders.select { |sh| sh.role == 'owner' } + stakeholders.build :person=>person, :role=>'owner' if person end end def stakeholders_before_add(sh) case sh.role - when :creator - errors.add :stakeholders, "Task cannot have two creators" unless in_role(:creator).empty? - when :owner + when 'creator' + errors.add :stakeholders, "Task cannot have two creators" unless in_role('creator').empty? + when 'owner' changed_attributes['owner'] ||= nil - errors.add :stakeholders, "Excluded owner #{sh.person.to_param} cannot become task owner" if in_role?(:excluded_owner, sh.person) - errors.add :stakeholders, "Task cannot have two owners" unless in_role(:owner).empty? - when :potential_owner - errors.add :stakeholders, "Excluded owner #{sh.person.to_param} cannot be potential owner" if in_role?(:excluded_owner, sh.person) + errors.add :stakeholders, "Excluded owner #{sh.person.to_param} cannot become task owner" if in_role?('excluded_owner', sh.person) + errors.add :stakeholders, "Task cannot have two owners" unless in_role('owner').empty? + when 'potential_owner' + errors.add :stakeholders, "Excluded owner #{sh.person.to_param} cannot be potential owner" if in_role?('excluded_owner', sh.person) end raise ActiveRecord::RecordInvalid, self if errors.on(:stakeholders) end def stakeholders_before_remove(sh) - changed_attributes['owner'] = sh.person if sh.role == :owner + changed_attributes['owner'] = sh.person if sh.role == 'owner' end private :stakeholders_before_add, :stakeholders_before_remove before_save do |task| past_owner, owner = task.changes['owner'] - task.stakeholders.build :role=>:potential_owner, :person=>owner if owner && !task.in_role?(:potential_owner, owner) - task.stakeholders.build :role=>:past_owner, :person=>past_owner if past_owner && !task.in_role?(:past_owner, past_owner) + task.stakeholders.build :role=>'potential_owner', :person=>owner if owner && !task.in_role?('potential_owner', owner) + task.stakeholders.build :role=>'past_owner', :person=>past_owner if past_owner && !task.in_role?('past_owner', past_owner) end =begin @@ -300,30 +300,30 @@ class Task < ActiveRecord::Base # * suspended -- Task is suspended. # * completed -- Task has completed. # * cancelled -- Task was cancelled. - STATUSES = [:available, :active, :suspended, :completed, :cancelled] + STATUSES = ['available', 'active', 'suspended', 'completed', 'cancelled'] - symbolize :status, :in=>STATUSES + validates_inclusion_of :status, :in=>STATUSES # Check method for each status (active?, completed?, etc). STATUSES.each { |status| define_method("#{status}?") { self.status == status } } before_validation do |task| case task.status - when :available + when 'available' # If we create the task with one potential owner, wouldn't it make sense to automatically assign it? - if !task.owner && (potential = task.in_role(:potential_owner)) && potential.size == 1 + if !task.owner && (potential = task.in_role('potential_owner')) && potential.size == 1 task.owner = potential.first end # Assigned task becomes active. - task.status = :active if task.owner - when :active + task.status = 'active' if task.owner + when 'active' # Unassigned task becomes available. - task.status = :available unless task.owner + task.status = 'available' unless task.owner end end def readonly? # :nodoc: - [:completed, :cancelled].include?(status_was) + ['completed', 'cancelled'].include?(status_was) end @@ -332,36 +332,36 @@ class Task < ActiveRecord::Base has_many :activities, :include=>[:task, :person], :order=>'activities.created_at desc', :dependent=>:delete_all before_create do |task| - creator = task.in_role(:creator).first + creator = task.in_role('creator').first task.modified_by ||= creator - task.activities.build :name=>:created, :person=>creator if creator - task.activities.build :name=>:claimed, :person=>task.owner if task.owner + task.activities.build :name=>'created', :person=>creator if creator + task.activities.build :name=>'claimed', :person=>task.owner if task.owner end before_update do |task| past_owner, owner = task.changes['owner'] if owner - task.activities.build :name=>:delegated, :person=>task.modified_by if task.modified_by && task.modified_by != owner - task.activities.build :name=>:claimed, :person=>owner + task.activities.build :name=>'delegated', :person=>task.modified_by if task.modified_by && task.modified_by != owner + task.activities.build :name=>'claimed', :person=>owner else - task.activities.build :name=>:released, :person=>past_owner + task.activities.build :name=>'released', :person=>past_owner end if task.status_changed? case task.status - when :active, :available - task.activities.build :name=>:resumed, :person=>task.modified_by if task.status_was == 'suspended' && task.modified_by - when :suspended - task.activities.build :name=>:suspended, :person=>task.modified_by if task.modified_by - when :completed - task.activities.build :name=>:completed, :person=>task.owner - when :cancelled - task.activities.build :name=>:cancelled, :person=>task.modified_by if task.modified_by + when 'active', 'available' + task.activities.build :name=>'resumed', :person=>task.modified_by if task.status_was == 'suspended' && task.modified_by + when 'suspended' + task.activities.build :name=>'suspended', :person=>task.modified_by if task.modified_by + when 'completed' + task.activities.build :name=>'completed', :person=>task.owner + when 'cancelled' + task.activities.build :name=>'cancelled', :person=>task.modified_by if task.modified_by end end changed = task.changed - ['status', 'owner'] - task.activities.build :name=>:modified, :person=>task.modified_by unless changed.empty? + task.activities.build :name=>'modified', :person=>task.modified_by unless changed.empty? end @@ -378,11 +378,11 @@ class Task < ActiveRecord::Base # Returns true if this person can own the task. Potential owners and supervisors can own the task, # excluded owners cannot (even if they appear in the other list). def can_own?(person) - (in_role?(:potential_owner, person) || in_role?(:supervisor, person)) && !in_role?(:excluded_owner, person) + (in_role?('potential_owner', person) || in_role?('supervisor', person)) && !in_role?('excluded_owner', person) end validate_on_update do |task| - by_supervisor = task.in_role?(:supervisor, task.modified_by) + by_supervisor = task.in_role?('supervisor', task.modified_by) past_owner, owner = task.changes['owner'] if past_owner != owner if owner @@ -400,13 +400,13 @@ class Task < ActiveRecord::Base end case task.status - when :available, :active + when 'available', 'active' task.errors.add :status, "Only supervisor is allowed to resume this task" if task.status_was == 'suspended' && !by_supervisor - when :suspended + when 'suspended' task.errors.add :status, "Only supervisor is allowed to suspend this task" unless by_supervisor - when :completed + when 'completed' task.errors.add :status, "Only owner can complete task" unless task.owner == task.modified_by - when :cancelled + when 'cancelled' task.errors.add :status, "Only supervisor allowed to cancel this task" unless by_supervisor end end @@ -552,24 +552,6 @@ class Task < ActiveRecord::Base # TODO: should be attribute end - def complete!(data = nil) - self.status = :completed - self.data = data if data - # TODO: Update outcome, observers - save! - end - - def cancel! - if reserved? - destroy - else - self.status = :cancelled - # TODO: Update outcome, observers - save! - end - end - - # --- Access control --- app/models/task.rb @@ -45,7 +45,6 @@ class Webhook < ActiveRecord::Base end belongs_to :task - validates_presence_of :task attr_accessible :event, :url, :http_method, :enctype, :hmac_key validates_presence_of :event, :url, :http_method, :enctype app/models/webhook.rb @@ -18,7 +18,7 @@ <td><%= content_tag 'span', ['High', 'Normal', 'Low'][task.priority - 1], :class=>"priority_#{task.priority}" %></td> <td><%= sparkline_tag [task.deadline], :type=>:deadline, :title=>"Due #{relative_date(task.due_on).titleize}" if task.due_on %></td> <td><%= abbr_time task.created_at, age(task.created_at, false), :class=>'published' %></td> - <td><%= link_to_person task.owner, :rel=>:owner if task.owner %><%= button_to 'Claim', task_url(task, 'task[owner]'=>authenticated), :method=>:put, :title=>'Claim this task' if task.can_claim?(authenticated) %></td> + <td><%= link_to_person task.owner, :rel=>'owner' if task.owner %><%= button_to 'Claim', task_url(task, 'task[owner]'=>authenticated), :method=>:put, :title=>'Claim this task' if task.can_claim?(authenticated) %></td> <% end %> <% end %> </tbody> app/views/tasks/tasks.html.erb @@ -80,13 +80,13 @@ class Populate < ActiveRecord::Migration # Completed, cancelled, suspended new_task! :potential_owner=>[@me, @bond], :supervisor=>@bond advance - @bond.tasks.last.update_attributes! :status=>:suspended + @bond.tasks.last.update_attributes! :status=>'suspended' new_task! :owner=>@me advance - @me.tasks.last.update_attributes! :status=>:completed + @me.tasks.last.update_attributes! :status=>'completed' advance new_task! :supervisor=>@me - @me.tasks.last.update_attributes! :status=>:cancelled + @me.tasks.last.update_attributes! :status=>'cancelled' end def self.down @@ -104,7 +104,7 @@ class Populate < ActiveRecord::Migration args[:potential_owner] ||= [@me, @bond] [:creator, :potential_owner, :excluded_owner, :supervisor, :observer].select { |role| args.has_key?(role) }.each do |role| Array(args[role]).each do |person| - task.stakeholders.build :role=>role, :person=>person + task.stakeholders.build :role=>role.to_s, :person=>person end end end.save! db/populate.rb @@ -27,7 +27,7 @@ end Given /^(.*) is (.*) of task "(.*)"$/ do |person, role, title| Given "the person #{person}" - Task.find_by_title(title).stakeholders.create! :role=>role.sub(' ', '_').to_sym, :person=>Person.identify(person) + Task.find_by_title(title).stakeholders.create! :role=>role.sub(' ', '_'), :person=>Person.identify(person) end @@ -39,13 +39,13 @@ When /^(\S*) (\S*) the task "(.*)"$/ do |person, action, title| when 'releases' task.update_attributes! :owner=>nil when 'suspends' - task.update_attributes! :status=>:suspended + task.update_attributes! :status=>'suspended' when 'resumes' - task.update_attributes! :status=>:active + task.update_attributes! :status=>'active' when 'completes' - task.update_attributes! :status=>:completed + task.update_attributes! :status=>'completed' when 'cancels' - task.update_attributes! :status=>:cancelled + task.update_attributes! :status=>'cancelled' else fail "Unknown action #{action}" end end features/step_definitions/task_steps.rb @@ -1,28 +1,28 @@ Feature: Listing tasks using API - Scenario: listing recently updated tasks - Given tasks from sample1.yaml - And I am authenticated as scott - When I request to view the updated task list - Then the response should be a task list - And with the following tasks in this order - """ - """ +# Scenario: listing recently updated tasks +# Given tasks from sample1.yaml +# And I am authenticated as scott +# When I request to view the updated task list +# Then the response should be a task list +# And with the following tasks in this order +# """ +# """ - Scenario: listing recently created tasks - Given tasks from sample1.yaml - And I am authenticated as scott - When I request to view the created task list - Then the response should be a task list - And with the following tasks in this order - """ - """ +# Scenario: listing recently created tasks +# Given tasks from sample1.yaml +# And I am authenticated as scott +# When I request to view the created task list +# Then the response should be a task list +# And with the following tasks in this order +# """ +# """ - Scenario: listing recently completed tasks - Given tasks from sample1.yaml - And I am authenticated as scott - When I request to view the created task list - Then the response should be a task list - And with the following tasks in this order - """ - """ +# Scenario: listing recently completed tasks +# Given tasks from sample1.yaml +# And I am authenticated as scott +# When I request to view the created task list +# Then the response should be a task list +# And with the following tasks in this order +# """ +# """ features/webapi/list_tasks.feature @@ -22,8 +22,7 @@ require 'rubygems/source_info_cache' # The plugins we maintain in vendor/plugins. -$plugins = 'git://github.com/assaf/presenter.git', - 'git://github.com/zargony/activerecord_symbolize.git' +$plugins = 'git://github.com/assaf/presenter.git' def check(message) script/setup @@ -32,7 +32,7 @@ class Person #:nodoc: # Convenient methods for roles, so owner() returns owner, and so forth. - [:creator, :owner, :supervisor, :potential, :excluded, :past_owner, :observer, :other].each do |role| + ['creator', 'owner', 'supervisor', 'potential', 'excluded', 'past_owner', 'observer', 'other'].each do |role| define_method(role) { Person.named(role.to_s) } end end @@ -41,16 +41,16 @@ end Task.blueprint do title { 'Spec me' } - status { :available } - object.associate :creator=>Person.creator, :supervisor=>Person.supervisor, - :potential_owner=>[Person.owner, Person.potential, Person.past_owner], - :past_owner=>Person.past_owner, :excluded_owner=>Person.excluded, :observer=>Person.observer - object.owner ||= Person.owner if object.status == :active || object.status == :completed + status { 'available' } + object.associate 'creator'=>Person.creator, 'supervisor'=>Person.supervisor, + 'potential_owner'=>[Person.owner, Person.potential, Person.past_owner], + 'past_owner'=>Person.past_owner, 'excluded_owner'=>Person.excluded, 'observer'=>Person.observer + object.owner ||= Person.owner if object.status == 'active' || object.status == 'completed' end class Task class << self - [:active, :suspended, :cancelled, :completed].each do |status| + ['active', 'suspended', 'cancelled', 'completed'].each do |status| define_method("make_#{status}") { Task.make :status=>status } end end @@ -79,13 +79,13 @@ end Stakeholder.blueprint do person { Person.make } - role { :owner } + role { 'owner' } task { Task.make } end Activity.blueprint do person { Person.make } - name { :created } + name { 'created' } task { Task.make } end spec/blueprints.rb @@ -30,7 +30,7 @@ class AuthenticationTestController < ApplicationController end describe AuthenticationTestController do - before { @person = Person.make(:email=>'me@example.com', :locale=>:tlh, :timezone=>-11) } + before { @person = Person.make(:email=>'me@example.com', :locale=>'tlh', :timezone=>-11) } describe 'unauthenticated request' do describe '(HTML)' do spec/controllers/authentication_spec.rb @@ -53,18 +53,13 @@ module Spec::Helpers #:nodoc: Hash.from_xml(entity) end -=begin - # Returns the currently authenticated person. - def authenticated - Person.find(session[:authenticated]) if session[:authenticated] - end - - # Returns true if the previous request was authenticated and authorized. - def authorized? - !(response.redirected_to == session_url || response.code == '401') - end -=end end end -Spec::Runner.configure { |config| config.include Spec::Helpers::Controllers, :type=>:controller } +Spec::Runner.configure do |config| + config.include Spec::Helpers::Controllers, :type=>:controller + config.after :each do + I18n.locale = nil + Time.zone = nil + end +end spec/controllers/helpers.rb @@ -111,8 +111,8 @@ describe TasksController do end it('should create new task from request entity') { new_task!.title.should == 'expenses' } - it('should set task creator to authenticated person') { new_task!.in_role(:creator).first.should == Person.creator } - it('should set task supervisor to authenticated person') { new_task!.in_role(:supervisor).first.should == Person.creator } + it('should set task creator to authenticated person') { new_task!.in_role('creator').first.should == Person.creator } + it('should set task supervisor to authenticated person') { new_task!.in_role('supervisor').first.should == Person.creator } it('should accept stakeholders as role/name pairs') { new_task!('stakeholders'=>[{'role'=>'owner', 'person'=>Person.owner.to_param}]) Task.last.owner.should == Person.owner } @@ -200,7 +200,7 @@ describe TasksController do end it 'should accept stakeholders as role/name pairs' do lambda { put :update, 'id'=>@task.id, 'task'=>{ 'stakeholders'=>[{ 'role'=>'observer', 'person'=>'other' }] } }. - should change { Task.last.in_role(:observer) }.to([Person.other]) + should change { Task.last.in_role('observer') }.to([Person.other]) end end spec/controllers/tasks_controller_spec.rb @@ -132,8 +132,8 @@ describe Person do it('should save task') { subject.should == Task.last } it('should return new task, modified_by person') { subject.modified_by.should == @bob } - it('should associate task with person as creator') { subject.in_role(:creator).should == [@bob] } - it('should associate task with person as supervisor') { subject.in_role(:supervisor).should == [@bob] } + it('should associate task with person as creator') { subject.in_role('creator').should == [@bob] } + it('should associate task with person as supervisor') { subject.in_role('supervisor').should == [@bob] } end describe '.create!' do spec/models/person_spec.rb @@ -40,7 +40,6 @@ describe Stakeholder do it { should validate_inclusion_of(:role, :in=>['creator', 'owner']) } it { should validate_inclusion_of(:role, :in=>['potential_owner', 'excluded_owner', 'past_owner']) } it { should validate_inclusion_of(:role, :in=>['supervisor', 'observer']) } - it { should have_readonly_attributes(:task, :role, :person) } it { should have_attribute(:created_at) } it { should have_db_column(:created_at, :type=>:datetime) } it { should validate_uniqueness_of(:role, :scope=>[:task_id, :person_id]) } spec/models/stakeholder_spec.rb @@ -92,20 +92,20 @@ describe Task do describe '#in_role' do before { @foo, @bar, @baz = Person.named('foo', 'bar', 'baz') } - it('should return all people in a given role') { subject.associate(:find=>[@foo, @bar], :miss=>@baz).in_role(:find).should == [@foo, @bar] } + it('should return all people in a given role') { subject.associate('find'=>[@foo, @bar], 'miss'=>@baz).in_role('find').should == [@foo, @bar] } end describe '#in_role?' do - subject { Task.make.associate(:find=>Person.named('foo', 'bar'), :miss=>Person.named('baz')) } - it('should identify all people in a given role') { [subject.in_role?(:find, 'foo'), subject.in_role?(:find, 'bar'), - subject.in_role?(:miss, 'foo')].should == [true, true, false] } - it('should return nil if no identity given') { subject.in_role?(:find, nil).should be_false } + subject { Task.make.associate('find'=>Person.named('foo', 'bar'), 'miss'=>Person.named('baz')) } + it('should identify all people in a given role') { [subject.in_role?('find', 'foo'), subject.in_role?('find', 'bar'), + subject.in_role?('miss', 'foo')].should == [true, true, false] } + it('should return nil if no identity given') { subject.in_role?('find', nil).should be_false } end describe 'creator' do subject { Person.creator } - it('should not have more than one creator') { lambda { Task.make.associate! :creator=>[subject, Person.owner] }. + it('should not have more than one creator') { lambda { Task.make.associate! 'creator'=>[subject, Person.owner] }. should raise_error(ActiveRecord::RecordInvalid) } it { should_not able_to_claim_task } it { should_not able_to_delegate_task } @@ -120,7 +120,7 @@ describe Task do subject { Task.make } it('should be nil if no person in this role') { subject.owner.should be_nil } - it('should return person in role owner') { subject.associate(:owner=>Person.owner).owner.should == Person.owner } + it('should return person in role owner') { subject.associate('owner'=>Person.owner).owner.should == Person.owner } it('should accept new owner') { lambda { subject.owner = Person.owner }.should change(subject, :owner).to(Person.owner) and lambda { subject.owner = Person.other }.should change(subject, :owner).to(Person.other) } end @@ -128,9 +128,9 @@ describe Task do describe 'owner' do subject { Person.owner } - it('should not have more than one owner') { lambda { Task.make.associate! :owner=>[subject, Person.owner] }. + it('should not have more than one owner') { lambda { Task.make.associate! 'owner'=>[subject, Person.owner] }. should raise_error(ActiveRecord::RecordInvalid) } - it('should default to single potential owner') { Task.make.tap { |t| t.associate!(:potential_owner=>subject) }.owner.should == subject } + it('should default to single potential owner') { Task.make.tap { |t| t.associate!('potential_owner'=>subject) }.owner.should == subject } it { should able_to_claim_task } it { should able_to_delegate_task } it { should_not able_to_suspend_task } @@ -143,7 +143,7 @@ describe Task do describe 'past owner' do subject { Person.past_owner } - it('should be previous owner of task') { subject.should == Task.make.in_role(:past_owner).first } + it('should be previous owner of task') { subject.should == Task.make.in_role('past_owner').first } it { should able_to_claim_task } it { should_not able_to_delegate_task } it { should_not able_to_suspend_task } @@ -220,11 +220,11 @@ describe Task do describe 'available' do subject { Task.make } - it('should be the initial status for new tasks') { Task.new(:status=>:active).status.should == :available } - it { should change_status_to(:active, "with new owner") { subject.update_attributes! :owner=>Person.owner } } + it('should be the initial status for new tasks') { Task.new(:status=>'active').status.should == 'available' } + it { should change_status_to('active', "with new owner") { subject.update_attributes! :owner=>Person.owner } } it { should_not change_status("on its own accord") { subject.save! } } it { should honor_cancellation_policy } - it { should_not change_status_to(:completed) { Person.supervisor.tasks.find(subject).update_attributes :owner=>Person.owner, :status=>:completed } } + it { should_not change_status_to('completed') { Person.supervisor.tasks.find(subject).update_attributes :owner=>Person.owner, :status=>'completed' } } it { should offer_potential_owner_to_claim } it { should offer_supervisor_to_suspend } it { should_not offer_supervisor_to_resume } @@ -236,14 +236,14 @@ describe Task do describe 'active' do subject { Task.make_active } - it('should be status for owned tasks') { subject.status.should == :active } - it { should change_status_to(:available, "if no owner") { Person.owner.tasks.find(subject).update_attributes :owner=>nil } } - it { should_not change_status("with owner change") { Person.owner.tasks.find(subject).update_attributes :owner=>Person.potential } } - it { should change_status_to(:suspended, "if suspended by supervisor") { Person.supervisor.tasks.find(subject).update_attributes :status=>:suspended } } - it { should_not change_status("unless suspended by supervisor") { Person.owner.tasks.find(subject).update_attributes :status=>:suspended } } + it('should be status for owned tasks') { subject.status.should == 'active' } + it { should change_status_to('available', "if no owner") { Person.owner.tasks.find(subject).update_attributes :owner=>nil } } + it { should_not change_status("with owner change") { Person.owner.tasks.find(subject).update_attributes :owner=>Person.potential } } + it { should change_status_to('suspended', "if suspended by supervisor") { Person.supervisor.tasks.find(subject).update_attributes :status=>'suspended' } } + it { should_not change_status("unless suspended by supervisor") { Person.owner.tasks.find(subject).update_attributes :status=>'suspended' } } it { should honor_cancellation_policy } - it { should change_status_to(:completed, "when completed by owner") { Person.owner.tasks.find(subject).update_attributes :status=>:completed } } - it { should_not change_status_to(:completed, "unless by owner") { Person.supervisor.tasks.find(subject).update_attributes :status=>:completed } } + it { should change_status_to('completed', "when completed by owner") { Person.owner.tasks.find(subject).update_attributes :status=>'completed' } } + it { should_not change_status_to('completed', "unless by owner") { Person.supervisor.tasks.find(subject).update_attributes :status=>'completed' } } it { should_not offer_potential_owner_to_claim } it { should_not offer_supervisor_to_suspend } it { should_not offer_supervisor_to_resume } @@ -255,11 +255,11 @@ describe Task do describe 'suspended' do subject { Task.make_suspended } - it { should change_status_to(:available, "if resumed and no owner") { Person.supervisor.tasks.find(subject).update_attributes! :status=>:active } } - it { should change_status_to(:active, "if resumed with owner") { subject.associate! :owner=>Person.owner ; Person.supervisor.tasks.find(subject).update_attributes! :status=>:available } } - it { should_not change_status("unless resumed by supervisor") { Person.owner.tasks.find(subject).update_attributes :status=>:active } } + it { should change_status_to('available', "if resumed and no owner") { Person.supervisor.tasks.find(subject).update_attributes! :status=>'active' } } + it { should change_status_to('active', "if resumed with owner") { subject.associate! 'owner'=>Person.owner ; Person.supervisor.tasks.find(subject).update_attributes! :status=>'available' } } + it { should_not change_status("unless resumed by supervisor") { Person.owner.tasks.find(subject).update_attributes :status=>'active' } } it { should honor_cancellation_policy } - it { should_not change_status_to(:completed) { Person.owner.tasks.find(subject).update_attributes :owner=>Person.owner, :status=>:completed } } + it { should_not change_status_to('completed') { Person.owner.tasks.find(subject).update_attributes :owner=>Person.owner, :status=>'completed' } } it { should_not offer_potential_owner_to_claim } it { should_not offer_supervisor_to_suspend } it { should offer_supervisor_to_resume } @@ -299,20 +299,20 @@ describe Task do subject { Person.creator.tasks.create!(:title=>'foo') } it { should be_available } - it('should have creator') { subject.in_role(:creator).should == [Person.creator] } - it('should have creator as supervisor') { subject.in_role(:supervisor).should == [Person.creator] } + it('should have creator') { subject.in_role('creator').should == [Person.creator] } + it('should have creator as supervisor') { subject.in_role('supervisor').should == [Person.creator] } it('should have no owner') { subject.owner.should be_nil } - it { should log_activity(Person.creator, :created) } + it { should log_activity(Person.creator, 'created') } end describe 'created and delegated' do subject { Person.creator.tasks.create!(:title=>'foo', :owner=>Person.owner) } it { should be_active } - it('should have creator') { subject.in_role(:creator).should == [Person.creator] } + it('should have creator') { subject.in_role('creator').should == [Person.creator] } it('should have owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.creator, :created) } - it { should log_activity(Person.owner, :claimed) } + it { should log_activity(Person.creator, 'created') } + it { should log_activity(Person.owner, 'claimed') } end describe 'owner claiming' do @@ -324,7 +324,7 @@ describe Task do it { should be_active } it('should have owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.owner, :claimed) } + it { should log_activity(Person.owner, 'claimed') } end describe 'owner delegating' do @@ -336,8 +336,8 @@ describe Task do it { should be_active } it('should have new owner') { subject.owner.should == Person.potential } - it { should log_activity(Person.owner, :delegated) } - it { should log_activity(Person.potential, :claimed) } + it { should log_activity(Person.owner, 'delegated') } + it { should log_activity(Person.potential, 'claimed') } end describe 'supervisor delegating' do @@ -349,8 +349,8 @@ describe Task do it { should be_active } it('should have new owner') { subject.owner.should == Person.potential } - it { should log_activity(Person.supervisor, :delegated) } - it { should log_activity(Person.potential, :claimed) } + it { should log_activity(Person.supervisor, 'delegated') } + it { should log_activity(Person.potential, 'claimed') } end describe 'owner releasing' do @@ -362,56 +362,56 @@ describe Task do it { should be_available } it('should have no owner') { subject.owner.should be_nil } - it { should log_activity(Person.owner, :released) } + it { should log_activity(Person.owner, 'released') } end describe 'supervisor suspending' do subject { Task.make_active } before do - Person.supervisor.tasks.find(subject).update_attributes! :status=>:suspended + Person.supervisor.tasks.find(subject).update_attributes! :status=>'suspended' subject.reload end it { should be_suspended } it('should retain owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.supervisor, :suspended) } + it { should log_activity(Person.supervisor, 'suspended') } end describe 'supervisor resuming' do subject { Task.make_active } before do - Person.supervisor.tasks.find(subject).update_attributes! :status=>:suspended - Person.supervisor.tasks.find(subject).update_attributes! :status=>:active + Person.supervisor.tasks.find(subject).update_attributes! :status=>'suspended' + Person.supervisor.tasks.find(subject).update_attributes! :status=>'active' subject.reload end it { should be_active } it('should retain owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.supervisor, :resumed) } + it { should log_activity(Person.supervisor, 'resumed') } end describe 'supervisor cancelling' do subject { Task.make_active } before do - Person.supervisor.tasks.find(subject).update_attributes! :status=>:cancelled + Person.supervisor.tasks.find(subject).update_attributes! :status=>'cancelled' subject.reload end it { should be_cancelled } it('should retain owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.supervisor, :cancelled) } + it { should log_activity(Person.supervisor, 'cancelled') } end describe 'owner completing' do subject { Task.make_active } before do - Person.owner.tasks.find(subject).update_attributes! :status=>:completed + Person.owner.tasks.find(subject).update_attributes! :status=>'completed' subject.reload end it { should be_completed } it('should retain owner') { subject.owner.should == Person.owner } - it { should log_activity(Person.owner, :completed) } + it { should log_activity(Person.owner, 'completed') } end describe 'supervisor modifying' do @@ -421,7 +421,7 @@ describe Task do subject.reload end - it { should log_activity(Person.supervisor, :modified) } + it { should log_activity(Person.supervisor, 'modified') } end @@ -463,8 +463,8 @@ describe Task do # -- Query scopes -- - it { should have_named_scope(:completed, :conditions=>"tasks.status = 'completed'", :order=>'tasks.updated_at desc') } - it { should have_named_scope(:cancelled, :conditions=>"tasks.status = 'cancelled'", :order=>'tasks.updated_at desc') } + it { should have_named_scope('completed', :conditions=>"tasks.status = 'completed'", :order=>'tasks.updated_at desc') } + it { should have_named_scope('cancelled', :conditions=>"tasks.status = 'cancelled'", :order=>'tasks.updated_at desc') } # Expecting the subject to change status after executing the block. Uses the reason argument @@ -506,7 +506,7 @@ describe Task do def honor_cancellation_policy simple_matcher "honor cancellation policy" do |given, matcher| matcher.failure_message = "expected status to change to cancelled, but did not change" - Person.supervisor.tasks.find(given).update_attributes :status=>:cancelled + Person.supervisor.tasks.find(given).update_attributes :status=>'cancelled' end end @@ -542,8 +542,8 @@ describe Task do def able_to_suspend_task simple_matcher "be offered/able to suspend task" do |given| task = Task.make - fail unless subject.can_suspend?(task) == subject.tasks.find(task).update_attributes(:status=>:suspended) - task.reload.status == :suspended + fail unless subject.can_suspend?(task) == subject.tasks.find(task).update_attributes(:status=>'suspended') + task.reload.status == 'suspended' end end @@ -556,8 +556,8 @@ describe Task do def able_to_resume_task simple_matcher "be offered/able to resume task" do |given| task = Task.make_suspended - fail unless subject.can_resume?(task) == subject.tasks.find(task).update_attributes(:status=>:available) - task.reload.status == :available + fail unless subject.can_resume?(task) == subject.tasks.find(task).update_attributes(:status=>'available') + task.reload.status == 'available' end end @@ -570,8 +570,8 @@ describe Task do def able_to_cancel_task simple_matcher "be offered/able to cancel task" do |given, matcher| task = Task.make - fail unless subject.can_cancel?(task) == subject.tasks.find(task).update_attributes(:status=>:cancelled) - task.reload.status == :cancelled + fail unless subject.can_cancel?(task) == subject.tasks.find(task).update_attributes(:status=>'cancelled') + task.reload.status == 'cancelled' end end @@ -584,8 +584,8 @@ describe Task do def able_to_complete_task simple_matcher "be offered/able to complete task" do |given, matcher| task = Task.make_active - fail unless subject.can_complete?(task) == subject.tasks.find(task).update_attributes(:status=>:completed) - task.reload.status == :completed + fail unless subject.can_complete?(task) == subject.tasks.find(task).update_attributes(:status=>'completed') + task.reload.status == 'completed' end end @@ -605,8 +605,8 @@ describe Task do def able_to_change_task(*attrs) simple_matcher "be able to change task" do |given| all = { :title=>'new title', :priority=>5, :due_on=>Date.tomorrow, :data=>{ 'foo'=>'bar' }, - :stakeholders=>[Stakeholder.new(:person=>Person.observer, :role=>:observer), - Stakeholder.new(:person=>Person.supervisor, :role=>:supervisor)] } + :stakeholders=>[Stakeholder.new(:person=>Person.observer, :role=>'observer'), + Stakeholder.new(:person=>Person.supervisor, :role=>'supervisor')] } changed = all.select { |attr, value| subject.tasks.find(Task.make_active).update_attributes(attr=>value) rescue false }.map(&:first) case attrs.first when nil, :any @@ -625,7 +625,7 @@ describe Task do # Expecting a new activity to show up after yielding to block, matching task (subject), person and name. # For example: - # it { should log_activity(Person.owner, :completed) { Person.owner.tasks(id).update_attributes :status=>:completed } } + # it { should log_activity(Person.owner, 'completed') { Person.owner.tasks(id).update_attributes :status=>'completed' } } def log_activity(person, name) simple_matcher "log activity '#{person.to_param} #{name}'" do |given, matcher| if block_given? spec/models/task_spec.rb @@ -34,7 +34,6 @@ describe Webhook do subject { Webhook.make } it { should belong_to(:task) } - it { should validate_presence_of(:task) } it { should have_attribute(:event) } it { should have_db_column(:event, :type=>:string) } spec/models/webhook_spec.rb @@ -20,7 +20,7 @@ module Presenter::ReadableAttributes end def to_hash - self.class.to_hash_attribute_names.inject Hash.new do |hash, attr| + self.class.to_hash_attribute_names.inject({}) do |hash, attr| value = send(attr) if value.respond_to?(:to_hash) value = value.to_hash vendor/plugins/presenter/lib/presenter/readable_attr.rb vendor/plugins/activerecord_symbolize/MIT-LICENSE vendor/plugins/activerecord_symbolize/README vendor/plugins/activerecord_symbolize/Rakefile vendor/plugins/activerecord_symbolize/init.rb vendor/plugins/activerecord_symbolize/lib/symbolize.rb vendor/plugins/activerecord_symbolize/test/symbolize_test.rb 5b132a2cbb8a3c337b2affe2ae41090888a639c7 Assaf Arkin assaf@labnotes.org http://github.com/assaf/singleshot/commit/d31341e94e984120453be1a6514ba4d61abb29a9 d31341e94e984120453be1a6514ba4d61abb29a9 2009-03-18T22:53:37-07:00 2009-03-18T22:52:38-07:00 No more activerecord_symbolize, too much trouble 86c3654dc847460260a69174b9e05dd15e628758 Assaf Arkin assaf@labnotes.org