hobo 0.8.3 → 0.8.4

data/lib/hobo/lifecycles/state.rb

@@ -2,13 +2,12 @@ module Hobo
 
   module Lifecycles
 
-    class State < Struct.new(:name, :on_enter, :transitions_in, :transitions_out)
+    class State < Struct.new(:name, :on_enter, :transitions_out)
 
       include Actions
 
       def initialize(*args)
         super
-        self.transitions_in  = []
         self.transitions_out = []
       end
 

data/lib/hobo/lifecycles/transition.rb

@@ -2,57 +2,51 @@ module Hobo
 
   module Lifecycles
 
-    class Transition < Struct.new(:lifecycle, :name, :who, :start_states, :end_state, :on_transition, :options)
+    class Transition < Struct.new(:lifecycle, :name, :start_states, :end_state, :on_transition, :options)
 
       include Actions
 
 
       def initialize(*args)
         super
+        self.name = name.to_sym
         start_states.each do |from|
-          state = lifecycle.states[from.to_s]
-          raise ArgumentError, "No such state '#{from}' in #{'name'} transition (#{lifecycle.model.name})" unless state
+          state = lifecycle.states[from]
+          raise ArgumentError, "No such state '#{from}' in #{name} transition (#{lifecycle.model.name})" unless state
           state.transitions_out << self
         end
-        unless end_state.to_s == "destroy"
-          state = lifecycle.states[end_state.to_s]
-          raise ArgumentError, "No such state '#{end_state}' in '#{name}' transition (#{lifecycle.model.name})" unless state
-          state.transitions_in << self
-        end
         lifecycle.transitions << self
       end
 
 
-      def allowed?(record, user, attributes=nil)
-        prepare_and_check!(record, user, attributes) && true
-      end
-
-
       def extract_attributes(attributes)
         update_attributes = options.fetch(:update, [])
         attributes & update_attributes
       end
+        
+      
+      def change_state(record)
+        record.lifecycle.become(get_state(record, end_state))
+      end
 
 
       def run!(record, user, attributes)
-        if prepare_and_check!(record, user, attributes)
-          if record.lifecycle.become end_state
-            fire_event(record, on_transition)
-          end
-        else
-          raise Hobo::Model::PermissionDeniedError
+        current_state = record.lifecycle.state_name
+        unless start_states.include?(current_state)
+          raise Hobo::Lifecycles::LifecycleError, "Transition #{record.class}##{name} cannot be run from the '#{current_state}' state"
         end
-      end
-
-
-      def set_or_check_who_with_key!(record, user)
-        if who == :with_key
-          record.lifecycle.valid_key? or raise LifecycleKeyError
-        else
-          set_or_check_who_without_key!(record, user)
+        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_transition)
+            end
+          else
+            raise Hobo::PermissionDeniedError
+          end
         end
       end
-      alias_method_chain :set_or_check_who!, :key
 
 
       def parameters

data/lib/hobo/model.rb

@@ -2,7 +2,6 @@ module Hobo
 
   module Model
 
-    class PermissionDeniedError < RuntimeError; end
     class NoNameError < RuntimeError; end
 
     NAME_FIELD_GUESS      = %w(name title)
@@ -13,8 +12,6 @@ module Hobo
     def self.included(base)
       base.extend(ClassMethods)
 
-      included_in_class_callbacks(base)
-
       register_model(base)
 
       patch_will_paginate
@@ -23,18 +20,15 @@ module Hobo
         inheriting_cattr_reader :default_order
         alias_method_chain :attributes=, :hobo_type_conversion
 
-        attr_accessor :acting_user, :origin, :origin_attribute
-
-        bool_attr_accessor :exempt_from_edit_checks
-
+        include Hobo::Permissions
         include Hobo::Lifecycles::ModelExtensions
         include Hobo::FindFor
-        include Hobo::MassAssignment
+        include Hobo::AccessibleAssociations
       end
 
       class << base
         alias_method_chain :belongs_to,    :creator_metadata
-        alias_method_chain :belongs_to,    :target_is
+        alias_method_chain :belongs_to,    :test_methods
         alias_method_chain :attr_accessor, :creator_metadata
 
         alias_method_chain :has_one, :new_method
@@ -49,10 +43,12 @@ module Hobo
       end
       
       base.fields # force hobofields to load
+
+      included_in_class_callbacks(base)
     end
 
     def self.patch_will_paginate
-      if defined?(WillPaginate) && !WillPaginate::Collection.respond_to?(:member_class)
+      if defined?(WillPaginate::Collection) && !WillPaginate::Collection.respond_to?(:member_class)
 
         WillPaginate::Collection.class_eval do
           attr_accessor :member_class, :origin, :origin_attribute
@@ -92,16 +88,45 @@ module Hobo
       # ...but only return the ones that registered themselves
       @model_names.*.constantize
     end
+    
+    
+    def self.find_by_typed_id(typed_id)
+      return nil if typed_id == 'nil'
+
+      _, name, id, attr = *typed_id.match(/^([^:]+)(?::([^:]+)(?::([^:]+))?)?$/)
+      raise ArgumentError.new("invalid typed-id: #{typed_id}") unless name
+
+      model_class = name.camelize.safe_constantize or raise ArgumentError.new("no such class in typed-id: #{typed_id}")
+      return nil unless model_class
+
+      if id
+        obj = model_class.find(id)
+          # Optimise: can we use eager loading in the situation where the attr is a belongs_to?
+          # We used to, but hit a bug in AR
+        attr ? obj.send(attr) : obj
+      else
+        model_class
+      end
+    end
 
 
     def self.enable
+      require 'active_record/association_collection'
+      require 'active_record/association_proxy'
+      require 'active_record/association_reflection'
+
       ActiveRecord::Base.class_eval do
         def self.hobo_model
           include Hobo::Model
           fields # force hobofields to load
         end
-
+        def self.hobo_user_model
+          include Hobo::Model
+          include Hobo::User
+        end
         alias_method :has_hobo_method?, :respond_to_without_attributes?
+        
+        Hobo::Permissions.enable
       end
     end
 
@@ -131,45 +156,6 @@ module Hobo
       end
 
 
-      def user_find(user, *args)
-        record = find(*args)
-        yield(record) if block_given?
-        raise PermissionDeniedError unless Hobo.can_view?(user, record)
-        record
-      end
-
-
-      def user_new(user, attributes={})
-        record = new(attributes) {|r| r.acting_user = user; yield if block_given? }
-        allowed = record.user_changes(user)
-        record.acting_user = nil
-        allowed && record
-      end
-
-
-      def user_new!(user, attributes={})
-        user_new(user, attributes) or raise PermissionDeniedError
-      end
-
-
-      def user_create(user, attributes={})
-        record = new(attributes)
-        record.user_save_changes(user)
-        record
-      end
-
-
-      def user_can_create?(user, attributes={})
-        record = new(attributes)
-        record.user_changes(user)
-      end
-
-
-      def user_update(user, id, attributes={})
-        find(id).user_save_changes(user, attributes)
-      end
-
-
       def name_attribute
         @name_attribute ||= begin
                               names = columns.*.name + public_instance_methods
@@ -212,20 +198,26 @@ module Hobo
         belongs_to_without_creator_metadata(name, options, &block)
       end
 
-      def belongs_to_with_target_is(name, options={}, &block)
-        belongs_to_without_target_is(name, options, &block)
+      def belongs_to_with_test_methods(name, options={}, &block)
+        belongs_to_without_test_methods(name, options, &block)
         refl = reflections[name]
         if options[:polymorphic]
           class_eval %{
             def #{name}_is?(target)
               target.id == self.#{refl.primary_key_name} && target.class.name == self.#{refl.options[:foreign_type]}
             end
+            def #{name}_changed?
+              #{refl.primary_key_name}_changed? || #{refl.options[:foreign_type]}_changed?
+            end
           }
         else
           class_eval %{
             def #{name}_is?(target)
               target.id == self.#{refl.primary_key_name}
             end
+            def #{name}_changed?
+              #{refl.primary_key_name}_changed?
+            end
           }
         end
       end
@@ -341,15 +333,17 @@ module Hobo
               r.source_reflection  == join_to_self
           end
         else
-          # Find the :belongs_to that corresponds to a :has_many or vice versa
+          # Find the :belongs_to that corresponds to a :has_one / :has_many or vice versa
+
+          reverse_macros = case refl.macro
+                           when :has_many, :has_one
+                             [:belongs_to]
+                           when :belongs_to
+                             [:has_many, :has_one]
+                           end
           
-          reverse_macro = if refl.macro == :has_many
-                            :belongs_to
-                          elsif refl.macro == :belongs_to
-                            :has_many
-                          end
           refl.klass.reflections.values.find do |r|
-            r.macro == reverse_macro &&
+            r.macro.in?(reverse_macros) &&
               r.klass == self &&
               !r.options[:conditions] &&
               r.primary_key_name == refl.primary_key_name
@@ -376,7 +370,7 @@ module Hobo
       end
 
 
-      def respond_to?(method)
+      def respond_to?(method, include_private=false)
         super || create_automatic_scope(method)
       end
 
@@ -396,6 +390,12 @@ module Hobo
       def typed_id
         HoboFields.to_name(self) || name.underscore.gsub("/", "__")
       end
+      
+      
+      def view_hints
+        class_name = "#{name}Hints"
+        class_name.safe_constantize or Object.class_eval("class #{class_name} < Hobo::ViewHints; end; #{class_name}")
+      end
 
 
     end # --- of ClassMethods --- #
@@ -411,8 +411,8 @@ module Hobo
     
     def to_param
       name_attr = self.class.name_attribute and name = send(name_attr)
-      if name_attr && !name.blank?
-        readable = name.to_s.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/-+$/, '').gsub(/^-+$/, '').split('-')[0..5].join('-')
+      if name_attr && !name.blank? && id.is_a?(Fixnum)
+        readable = name.to_s.downcase.gsub(/[^a-z0-9]+/, '-').gsub(/-+$/, '').gsub(/^-+/, '').split('-')[0..5].join('-')
         @to_param ||= "#{id}-#{readable}"
       else
         id.to_s
@@ -420,73 +420,6 @@ module Hobo
     end
 
 
-    def with_acting_user(user)
-      old = acting_user
-      self.acting_user = user
-      result = yield
-      self.acting_user = old
-      result
-    end
-
-
-    def user_changes(user, changes={})
-      with_acting_user user do
-        if new_record?
-          self.attributes = changes
-          set_creator(user)
-          Hobo.can_create?(user, self)
-        else
-          original = duplicate
-          # 'duplicate' can cause these to be set, but they can conflict
-          # with the changes so we clear them
-          clear_aggregation_cache
-          clear_association_cache
-
-          self.attributes = changes
-
-          Hobo.can_update?(user, original, self)
-        end
-      end
-    end
-
-
-    def user_changes!(user, changes={})
-      user_changes(user, changes) or raise PermissionDeniedError
-    end
-
-
-    def user_can_create?(user, attributes={})
-      raise ArgumentError, "Called #user_can_create? on existing record" unless new_record?
-      user_changes(user, attributes)
-    end
-
-
-    def user_save_changes(user, changes={})
-      with_acting_user user do
-        user_changes!(user, changes)
-        save
-      end
-    end
-
-
-    def user_save(user)
-      user_save_changes(user)
-    end
-
-
-    def user_view(user, field=nil)
-      raise PermissionDeniedError, self.inspect unless Hobo.can_view?(user, self, field)
-    end
-
-
-    def user_destroy(user)
-      with_acting_user user do
-        raise PermissionDeniedError unless Hobo.can_delete?(user, self)
-        destroy
-      end
-    end
-
-
     def dependent_on
       self.class.dependent_on.map { |assoc| send(assoc) }
     end
@@ -567,7 +500,7 @@ module Hobo
 
 
     def typed_id
-      "#{self.class.name.underscore}_#{self.id}" if id
+      "#{self.class.name.underscore}:#{self.id}" if id
     end
 
 
@@ -583,19 +516,8 @@ module Hobo
     private
 
 
-    def parse_datetime(s)
-      defined?(Chronic) ? Chronic.parse(s) : Time.parse(s)
-    end
-
-
     def convert_type_for_mass_assignment(field_type, value)
-      if field_type.is_a?(Class) && field_type < ActiveRecord::Base
-        convert_record_reference_for_mass_assignment(field_type, value)
-
-      elsif field_type.is_a?(ActiveRecord::Reflection::AssociationReflection)
-        convert_collection_for_mass_assignment(field_type, value)
-
-      elsif !field_type.is_a?(Class)
+      if !field_type.is_a?(Class)
         value
 
       elsif field_type <= Date
@@ -606,9 +528,6 @@ module Hobo
           else
             Date.new(*parts)
           end
-        elsif value.is_a? String
-          dt = parse_datetime(value)
-          dt && dt.to_date
         else
           value
         end
@@ -616,8 +535,6 @@ module Hobo
       elsif field_type <= Time || field_type <= ActiveSupport::TimeWithZone
         if value.is_a? Hash
           Time.local(*(%w{year month day hour minute}.map{|s| value[s].to_i}))
-        elsif value.is_a? String
-          parse_datetime(value)
         else
           value
         end
@@ -632,35 +549,6 @@ module Hobo
     end
 
 
-    def convert_record_reference_for_mass_assignment(klass, value)
-      if value.is_a?(String)
-        if value.starts_with?('@')
-          # TODO: This @foo_1 feature is rarely (never?) used - get rid of it
-          Hobo.object_from_dom_id(value[1..-1])
-        else
-          klass.named(value)
-        end
-      else
-        value
-      end
-    end
-
-
-    def convert_collection_for_mass_assignment(reflection, value)
-      klass = reflection.klass
-      if klass.try.name_attribute && value.is_a?(Array)
-        value.map do |x|
-          if x.is_a?(String)
-            klass.named(x) unless x.blank?
-          else
-            x
-          end
-        end.compact
-      else
-        value
-      end
-    end
-
   end
 
 end