hobo 0.8.3 → 0.8.4

data/lib/hobo/lifecycles/actions.rb

@@ -1,73 +1,137 @@
+# We need to be able to eval an expression outside of the Hobo module
+# so that, e.g. "Userd" doesn't eval to "Hobo::User"
+# (Ruby determines this constant lookup scope lexically)
+def __top_level_eval__(obj, expr)
+  obj.instance_eval(expr)
+end
+  
 module Hobo
 
   module Lifecycles
 
     module Actions
 
-      def set_or_check_who!(record, user)
+      def available_to_acting_user?(record)
+        return true if available_to.nil? # available_to not specified (these steps are not published)
+        acting_user_is?(available_to, record)
+      end
+      
+      
+      def acting_user_is?(who, record)
+        user = record.acting_user
+
         case who
-        when :nobody
-          user == :nobody
-        when :anybody
+        when :all
           true
+
+        when :key_holder
+          record.lifecycle.valid_key?
+
         when :self
           record == user
+
         when Array
-          who.detect {|attribute| record.send(attribute) == user }
+          # recursively apply the same test to every item in the array
+          who.detect { |w| acting_user_is?(w, record) }
+
         else
-          if (current = record.send(who)) # it's already set, check it's the same user
-            user == current
-          elsif user.is_a?(record.class.attr_type(who))
-            record.send("#{who}=", user)
-            true
+          refl = record.class.reflections[who]
+          if refl && refl.macro == :has_many
+            send(who).include?(user)
+          elsif refl && refl.macro == :belongs_to
+            send("#{who}_is?", user)
           else
-            false
+            value = run_hook(record, who)
+            if value.is_a?(Class)
+              user.is_a?(value)
+            elsif value.respond_to?(:include?)
+              value.include?(user)
+            else
+              value == user
+            end
           end
         end
       end
 
 
       def run_hook(record, hook, *args)
-        if hook.is_a?(Symbol)
+        case hook
+        when Symbol
           record.send(hook, *args)
-        elsif hook.is_a?(Proc)
-          hook.call(record, *args)
+        when String
+          __top_level_eval__(record, hook)
+        when Proc
+          if hook.arity == 1
+            hook.call(record)
+          else
+            record.instance_eval(&hook)
+          end
         end
       end
 
 
       def fire_event(record, event)
-        record.instance_eval(&event) if event
+        if event
+          if event.arity == 1
+            event.call(record)
+          else
+            record.instance_eval(&event)
+          end
+        end
       end
 
 
-      def check_guard(record, user)
-        !options[:if] || run_hook(record, options[:if], user)
-      end
-
-      def check_invariants(record)
-        record.lifecycle.invariants_satisfied?
+      def guard_ok?(record)
+        if options[:if]
+          raise ArgumentError, "do not provide both :if and :unless to lifecycle steps" if options[:unless]
+          run_hook(record, options[:if])
+        elsif options[:unless]
+          !run_hook(record, options[:unless])
+        else
+          true
+        end
       end
 
 
-      def prepare(record, user, attributes=nil)
-        if attributes
-          attributes = extract_attributes(attributes)
-          record.attributes = attributes
-        end
+      def prepare!(record, attributes)
+        record.attributes = extract_attributes(attributes) if attributes
         record.lifecycle.generate_key if options[:new_key]
-        set_or_check_who!(record, user) && record
+        apply_user_becomes!(record)
       end
 
 
-      def prepare_and_check!(record, user, attributes=nil)
-        prepare(record, user, attributes) && check_guard(record, user) && check_invariants(record)
+      def can_run?(record)
+        available_to_acting_user?(record) && guard_ok?(record) && record.lifecycle.invariants_satisfied?
+      end
+      
+      
+      def available_to
+        options[:available_to]
       end
       
+      
       def publishable?
-        who != :nobody
+        available_to
       end
-
+      
+      
+      def apply_user_becomes!(record)
+        if (assoc = options[:user_becomes])
+          record.send("#{assoc}=", record.acting_user)
+        end
+      end
+      
+      def get_state(record, state)
+        case state
+        when Proc
+          state.call(record)
+        when String
+          eval(state, record.instance_eval { binding })
+        else
+          state
+        end
+      end
+            
     end
 
   end

data/lib/hobo/lifecycles/creator.rb

@@ -1,35 +1,25 @@
 module Hobo
   module Lifecycles
 
-    class Creator < Struct.new(:lifecycle, :name, :who, :on_create, :options)
+    class Creator < Struct.new(:lifecycle, :name, :on_create, :options)
 
       def initialize(*args)
         super
+        self.name = name.to_sym
         lifecycle.creators[name] = self
       end
 
       include Actions
 
-      def check_preconditions(record)
-        record.lifecycle.preconditions_satisfied?
-      end
-
-
-      def prepare_and_check_with_preconditions!(record, user, attributes=nil)
-        prepare_and_check_without_preconditions!(record, user, attributes) && check_preconditions(record)
-      end
-      alias_method_chain :prepare_and_check!, :preconditions
-
-
-      def allowed?(user, attributes=nil)
+      def allowed?(user)
         record = lifecycle.model.new
-        prepare_and_check!(record, user, attributes)
+        record.with_acting_user(user) { can_run?(record) }
       end
 
 
       def candidate(user, attributes=nil)
         record = lifecycle.model.new
-        prepare_and_check!(record, user, attributes)
+        record.with_acting_user(user) { prepare!(record, attributes) }
         record.exempt_from_edit_checks = true
         record
       end
@@ -42,6 +32,7 @@ module Hobo
         params.each do |p|
           if (refl = model.reflections[p]) && refl.macro == :belongs_to
             allowed << refl.primary_key_name.to_s
+            allowed << refl.options[:foreign_type] if refl.options[:polymorphic]
           end
         end
         attributes & allowed
@@ -49,20 +40,24 @@ module Hobo
 
 
       def change_state(record)
-        state = options[:become]
-        record.lifecycle.become(state) if state
+        state = get_state(record, options[:become])
+        record.lifecycle.become state if state
       end
 
 
       def run!(user, attributes)
         record = lifecycle.model.new
-        if prepare_and_check!(record, user, attributes)
-          if change_state(record)
-            fire_event(record, on_create)
+        record.lifecycle.active_step = self
+        record.with_acting_user(user) do
+          prepare!(record, attributes)
+          if can_run?(record)
+            if change_state(record)
+              fire_event(record, on_create)
+            end
+            record
+          else
+            raise Hobo::PermissionDeniedError
           end
-          record
-        else
-          raise Hobo::Model::PermissionDeniedError
         end
       end
 

data/lib/hobo/lifecycles/lifecycle.rb

@@ -14,49 +14,51 @@ module Hobo
         @states        = {}
         @creators      = {}
         @transitions   = []
-        @preconditions = []
         @invariants    = []
       end
 
       class << self
-        attr_accessor :model, :options, :states, :initial_state,
-                      :creators, :transitions, :invariants, :preconditions
+        attr_accessor :model, :options, :states, :default_state,
+                      :creators, :transitions, :invariants
       end
 
       def self.def_state(name, on_enter)
-        name = name.to_s
-        returning(State.new(name, on_enter)) do |s|
+        name = name.to_sym
+        returning(Lifecycles::State.new(name, on_enter)) do |s|
           states[name] = s
-          class_eval "def #{name}_state?; state_name == '#{name}' end"
+          class_eval "def #{name}_state?; state_name == :#{name} end"
         end
       end
 
 
-      def self.def_creator(name, who, on_create, options)
-        name = name.to_s
-        returning(Creator.new(self, name, who, on_create, options)) do |creator|
+      def self.def_creator(name, on_create, options)
+        name = name.to_sym
+        returning(Creator.new(self, name, on_create, options)) do |creator|
 
           class_eval %{
                        def self.#{name}(user, attributes=nil)
-                         create('#{name}', user, attributes)
+                         create(:#{name}, user, attributes)
                        end
                        def self.can_#{name}?(user, attributes=nil)
-                         can_create?('#{name}', user, attributes)
+                         can_create?(:#{name}, user)
                        end
                       }
 
        end
       end
 
-      def self.def_transition(name, who, start_state, end_states, on_transition, options)
-        returning(Transition.new(self, name.to_s, who, start_state, end_states, on_transition, options)) do |t|
+      def self.def_transition(name, start_state, end_states, on_transition, options)
+        returning(Transition.new(self, name.to_s, start_state, end_states, on_transition, options)) do |t|
 
           class_eval %{
-                       def #{name}(user, attributes=nil)
-                         transition('#{name}', user, attributes)
+                       def #{name}!(user, attributes=nil)
+                         transition(:#{name}, user, attributes)
                        end
                        def can_#{name}?(user, attributes=nil)
-                         can_transition?('#{name}', user, attributes)
+                         can_transition?(:#{name}, user)
+                       end
+                       def valid_for_#{name}?
+                         valid_for_transition?(:#{name})
                        end
                       }
 
@@ -66,28 +68,33 @@ module Hobo
       def self.state_names
         states.keys
       end
-
-
-      def self.can_create?(name, user, attributes=nil)
-        creators[name.to_s].allowed?(user, attributes)
+      
+      def self.publishable_creators
+        creators.values.where.publishable?
       end
-
-
-      def self.create(name, user, attributes=nil)
-        creator = creators[name.to_s]
-        record = creator.run!(user, attributes)
-        record.lifecycle.active_step = creator
-        record
+      
+      def self.publishable_transitions
+        transitions.where.publishable?
+      end
+      
+      def self.step_names 
+        (creators.keys | transitions.*.name).uniq
+      end
+      
+      
+      def self.creator(name)
+        creators[name.to_sym] or raise ArgumentError, "No such creator in lifecycle: #{name}"
       end
 
 
-      def self.creator_names
-        creators.keys
+      def self.can_create?(name, user)
+        creators[name.to_sym].allowed?(user)
       end
 
 
-      def self.transition_names
-        transitions.*.name.uniq
+      def self.create(name, user, attributes=nil)
+        creator = creators[name.to_sym]
+        creator.run!(user, attributes)
       end
 
 
@@ -108,26 +115,33 @@ module Hobo
       end
 
 
-      def can_transition?(name, user, attributes=nil)
-        available_transitions_for(user, name, attributes).any?
+      def can_transition?(name, user)
+        available_transitions_for(user, name).any?
       end
 
 
-      def transition(name, user, attributes=nil)
-        transition = find_transition(name, user, attributes)
-        self.active_step = transition
+      def transition(name, user, attributes)
+        transition = find_transition(name, user)
         transition.run!(record, user, attributes)
       end
 
 
-      def find_transition(name, user, attributes=nil)
-        available_transitions_for(user, name, attributes).first or
-          raise LifecycleError, "No #{name} transition available to #{user} on this #{record.class.name}"
+      def find_transition(name, user)
+        available_transitions_for(user, name).first
+      end
+      
+      
+      def valid_for_transition?(name)
+        record.valid?
+        callback = :"validate_on_#{name}"
+        record.run_callbacks callback
+        record.send callback
+        record.errors.empty?
       end
 
 
       def state_name
-        record.read_attribute self.class.state_field
+        record.read_attribute(self.class.state_field).to_sym
       end
 
 
@@ -141,36 +155,38 @@ module Hobo
       end
 
 
-      def available_transitions_for(user, name=nil, attributes=nil)
+      def available_transitions_for(user, name=nil)
+        name = name.to_sym if name
         matches = available_transitions
-        matches = matches.select { |t| t.name == name.to_s } if name
-        matches.select { |t| t.allowed?(record, user, attributes) }
+        matches = matches.select { |t| t.name == name } if name
+        record.with_acting_user(user) do
+          matches.select { |t| t.can_run?(record) }
+        end
       end
 
 
       def become(state_name, validate=true)
-        state_name = state_name.to_s
-        if self.state != state_name
-          record.write_attribute self.class.state_field, state_name
-
-          if state_name == "destroy"
-            record.destroy
+        state_name = state_name.to_sym
+        record.write_attribute self.class.state_field, state_name.to_s
+
+        if state_name == :destroy
+          record.destroy
+          true
+        else
+          s = self.class.states[state_name]
+          raise ArgumentError, "No such state '#{state_name}' for #{record.class.name}" unless s
+          
+          if record.save(validate)
+            s.activate! record
+            self.active_step = nil # That's the end of this step
             true
           else
-            s = self.class.states[state_name]
-            raise ArgumentError, "No such state '#{state_name}' for #{record.class.name}" unless s
-            if record.save(validate)
-              s.activate! record
-              self.active_step = nil # That's the end of this step
-              true
-            else
-              false
-            end
+            false
           end
         end
       end
-
-
+            
+      
       def key_timestamp_field
         record.class::Lifecycle.options[:key_timestamp_field]
       end
@@ -205,8 +221,16 @@ module Hobo
       end
 
 
-      def preconditions_satisfied?
-        self.class.preconditions.all? { |i| record.instance_eval(&i) }
+      def active_step_is?(name)
+        active_step && active_step.name == name.to_sym
+      end
+      
+      def method_missing(name, *args)
+        if name.to_s =~ /^(.*)_in_progress\?$/
+          active_step_is?($1)
+        else
+          super
+        end
       end
 
     end