hobo 0.8.3 → 0.8.4

data/lib/hobo/guest.rb

@@ -5,7 +5,7 @@ module Hobo
     alias_method :has_hobo_method?, :respond_to?
 
     def to_s
-      "Guest"
+      "guest"
     end
 
     def guest?
@@ -16,16 +16,8 @@ module Hobo
       false
     end
 
-    def super_user?
-      false
-    end
-
-    def administrator?
-      false
-    end
-
     def login
-      "Guest"
+      "guest"
     end
 
   end

data/lib/hobo/hobo_helper.rb

@@ -20,7 +20,7 @@ module Hobo
       # simple one-hit-per-request cache
       @current_user ||= begin
                           id = session._?[:user]
-                          (id && Hobo.object_from_dom_id(id) rescue nil) || ::Guest.new
+                          (id && Hobo::Model.find_by_typed_id(id) rescue nil) || ::Guest.new
                         end
     end
 
@@ -31,7 +31,7 @@ module Hobo
 
 
     def base_url
-      request.relative_url_root
+      ActionController::Base.relative_url_root || ""
     end
 
 
@@ -58,7 +58,7 @@ module Hobo
       options[:subsite] ||= self.subsite
       subsite, method = options.get :subsite, :method
 
-      if obj.respond_to?(:member_class)
+      if obj.respond_to?(:member_class) && obj.respond_to?(:origin)
         # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
         
         refl = obj.origin.class.reverse_reflection(obj.origin_attribute)
@@ -90,7 +90,13 @@ module Hobo
           obj = obj.class
         end
         
-        klass = obj.is_a?(Class) ? obj : obj.class
+        klass = if obj.is_a?(Class)
+                  obj
+                elsif obj.respond_to?(:member_class)
+                  obj.member_class # We get here if we're passed a scoped class
+                else
+                  obj.class
+                end
       end
 
       if Hobo::ModelRouter.linkable?(klass, action, options)
@@ -119,7 +125,7 @@ module Hobo
         "#{name}=' + #{obj} + '"
       else
         v = if obj.is_a?(ActiveRecord::Base) or obj.is_a?(Array)
-              "@" + dom_id(obj)
+              "@" + typed_id(obj)
             else
               obj.to_s.gsub("'"){"\\'"}
             end
@@ -148,7 +154,7 @@ module Hobo
 
 
     def model_id_class(object=this, attribute=nil)
-      object.respond_to?(:typed_id) ? "model:#{dom_id(object, attribute).dasherize}" : ""
+      object.respond_to?(:typed_id) ? "model::#{typed_id(object, attribute).to_s.dasherize}" : ""
     end
 
 
@@ -156,12 +162,13 @@ module Hobo
       # TODO: Calls to respond_to? in here can cause the full collection hiding behind a scoped collection to get loaded
       res = []
       empty = true
-      scope.new_scope(:repeat_collection => enum) do
+      scope.new_scope(:repeat_collection => enum, :even_odd => 'odd') do
         if enum.respond_to?(:each_pair)
           enum.each_pair do |key, value|
             empty = false;
             self.this_key = key;
             new_object_context(value) { res << yield }
+            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
           end
         else
           index = 0
@@ -172,6 +179,7 @@ module Hobo
             else
               new_object_context(e) { res << yield }
             end
+            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
             index += 1
           end
         end
@@ -195,8 +203,6 @@ module Hobo
       case x
       when nil
         []
-      when Symbol
-        x.to_s
       when String
         x.strip.split(/\s*,\s*/)
       else
@@ -206,58 +212,113 @@ module Hobo
 
 
     def can_create?(object=this)
-      Hobo.can_create?(current_user, object)
+      if object.is_a?(Class) and object < ActiveRecord::Base
+        object = object.new
+      elsif (refl = object.try.proxy_reflection) && refl.macro == :has_many
+        if Hobo.simple_has_many_association?(object)
+          object = object.new
+          object.set_creator(current_user)
+        else
+          return false
+        end
+      end
+      object.creatable_by?(current_user)
     end
 
 
-    def can_update?(object, new)
-      Hobo.can_update?(current_user, object, new)
+    def can_update?(object=this)
+      object.updatable_by?(current_user)
     end
 
 
     def can_edit?(*args)
-      if args.empty?
-        if this.respond_to?(:updatable_by?) && !this_field_reflection
-          can_edit?(this, nil)
-        elsif this_parent && this_field
-          can_edit?(this_parent, this_field)
-        else
-          can_edit?(this, nil)
-        end
-      else
-        object, field = args.length == 2 ? args : [this, args.first]
-
-        if !field && (origin = object.try.origin)
-          Hobo.can_edit?(current_user, origin, object.origin_attribute)
-        else
-          Hobo.can_edit?(current_user, object, field)
-        end
+      object, field = if args.empty?
+                        if this.respond_to?(:editable_by?) && !this_field_reflection
+                          [this, nil]
+                        elsif this_parent && this_field
+                          [this_parent, this_field]
+                        else 
+                          [this, nil]
+                        end
+                      elsif args.length == 2
+                        args
+                      else
+                        [this, args.first]
+                      end
+
+      if !field && (origin = object.try.origin)
+        object, field = origin, object.origin_attribute
       end
-    end
 
+      object.editable_by?(current_user, field)
+    end
+    
 
-    def can_delete?(object=nil)
-      Hobo.can_delete?(current_user, object || this)
+    def can_delete?(object=this)
+      object.destroyable_by?(current_user)
     end
 
 
-    def can_view?(object=nil, field=nil)
-      if object.nil? && field.nil?
+    
+    def can_call?(*args)
+      method = args.last
+      object = args.length == 2 ? args.first : this
+
+      object.method_callable_by?(current_user, method)
+    end
+
+    
+    # can_view? has special behaviour if it's passed a class or an
+    # association-proxy -- it instantiates the class, or creates a new
+    # instance "in" the association, and tests the permission of this
+    # object. This means the permission methods in models can't rely
+    # on the instance being properly initialised.  But it's important
+    # that it works like this because, in the case of an association
+    # proxy, we don't want to loose the information that the object
+    # belongs_to the proxy owner.
+    def can_view?(*args)
+      # TODO: Man does this need a big cleanup!
+      
+      if args.empty?
         if this_parent && this_field
-          object, field = this_parent, this_field
+          object = this_parent
+          field = this_field
         else
           object = this
         end
+      elsif args.first.is_a?(String, Symbol)
+        object = this
+        field  = args.first
+      else
+        object, field = args
       end
-
+      
+      if field
+        # Field can be a dot separated path
+        if field.is_a?(String) && (path = field.split(".")).length > 1
+          _, _, object = Hobo.get_field_path(object, path[0..-2])
+          field = path.last
+        end
+      elsif (origin = object.try.origin)
+        object, field = origin, object.origin_attribute
+      end
+      
       @can_view_cache ||= {}
       @can_view_cache[ [object, field] ] ||=
-        if !field && (origin = object.try.origin)
-          Hobo.can_view?(current_user, origin, object.origin_attribute)
+        if !object.respond_to?(:viewable_by)
+          true
+        elsif object.viewable_by?(current_user, field)
+          # If possible, we also check if the current *value* of the field is viewable
+          if field.is_a?(Symbol, String) && (v = object.send(field)) && v.respond_to?(:viewable_by?)
+            v.viewable_by?(current_user, nil)
+          else
+            true
+          end
         else
-          Hobo.can_view?(current_user, object, field)
+          false
         end
     end
+    
 
 
     def select_viewable(collection=this)
@@ -289,19 +350,19 @@ module Hobo
     end
 
 
-    def param_name_for(object, field_path)
+    def param_name_for(path)
       field_path = field_path.to_s.split(".") if field_path.is_a?(String, Symbol)
-      attrs = field_path.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
-      "#{object.class.name.underscore}#{attrs}"
+      attrs = path.rest.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
+      "#{path.first}#{attrs}"
     end
 
 
     def param_name_for_this(foreign_key=false)
       return "" unless form_this
       name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to
-               param_name_for(form_this, form_field_path[0..-2] + [refl.primary_key_name])
+               param_name_for(path_for_form_field[0..-2] + [refl.primary_key_name])
              else
-               param_name_for(form_this, form_field_path)
+               param_name_for(path_for_form_field)
              end
       register_form_field(name)
       name
@@ -366,17 +427,16 @@ module Hobo
     end
 
     def query_params
-      query = request.request_uri.match(/(?:\?([^?]+))/)._?[1]
+      query = request.request_uri =~ /\?([^?]+)/ && $1
+      result = HashWithIndifferentAccess.new 
       if query
-        params = query.split('&')
-        pairs = params.map do |param|
-          pair = param.split('=', 2)
-          pair.length == 1 ? pair + [''] : pair
+        query.gsub!('+', ' ')
+        query.split('&').each do |param|
+          name, val = param.split('=', 2)
+          result[URI.unescape(name)] = val ? URI.unescape(val) : ''
         end
-        HashWithIndifferentAccess[*pairs.flatten]
-      else
-        HashWithIndifferentAccess.new
       end
+      result
     end
 
     def linkable?(*args)
@@ -384,7 +444,7 @@ module Hobo
       target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
       action = args.first
 
-      if (origin = target.try.origin)
+      if target.respond_to?(:member_class) && (origin = target.try.origin)
         klass = origin.class
         action = if action == :new
                    "new_#{target.origin_attribute.to_s.singularize}"
@@ -401,7 +461,11 @@ module Hobo
 
       Hobo::ModelRouter.linkable?(klass, action, options.reverse_merge(:subsite => subsite))
     end
-
+    
+    def css_data(name, *args)
+      "#{name.to_s.dasherize}::#{args * '::'}"
+    end
+    
 
     # Convenience helper for the default app
 
@@ -409,7 +473,15 @@ module Hobo
     def front_models
       Hobo::Model.all_models.select {|m| linkable?(m) }
     end
+    
+    
+    def this_field_name
+      this_parent.class.view_hints.field_name(this_field)
+    end
 
+    def this_field_help
+      this_parent.class.view_hints.field_help[this_field.to_sym]
+    end
 
 
     # debugging support

data/lib/hobo/include_in_save.rb

@@ -35,7 +35,6 @@ module Hobo
       if included_in_save
         included_in_save.each_pair do |association, records|
           records.each do |record|
-            record.user_changes(acting_user) if acting_user
             record.save_without_validation # This means without transactions too
           end
         end

data/lib/hobo/lifecycles.rb

@@ -9,7 +9,11 @@ module Hobo
     ModelExtensions = classy_module do
 
       attr_writer :lifecycle
-
+      
+      def self.has_lifecycle?
+        defined?(self::Lifecycle)
+      end
+      
       def self.lifecycle(*args, &block)
         options = args.extract_options!
         options = options.reverse_merge(:state_field => :state,
@@ -18,6 +22,8 @@ module Hobo
         if defined? self::Lifecycle
           lifecycle = self::Lifecycle
         else
+          # First call
+          
           module_eval "class ::#{name}::Lifecycle < Hobo::Lifecycles::Lifecycle; end"
           lifecycle = self::Lifecycle
           lifecycle.init(self, options)
@@ -26,19 +32,46 @@ module Hobo
         dsl = DeclarationDSL.new(lifecycle)
         dsl.instance_eval(&block)
 
-        default = lifecycle.initial_state ? { :default => lifecycle.initial_state.name } : {}
+        default = lifecycle.default_state ? { :default => lifecycle.default_state.name.to_s } : {}
         declare_field(options[:state_field], :string, default)
+        never_show      options[:state_field]
+        attr_protected  options[:state_field]
 
-        declare_field(options[:key_timestamp_field], :datetime)
-
-        never_show      options[:state_field], options[:key_timestamp_field]
-        attr_protected  options[:state_field], options[:key_timestamp_field]
+        unless options[:key_timestamp_field] == false
+          declare_field(options[:key_timestamp_field], :datetime)
+          never_show      options[:key_timestamp_field]
+          attr_protected  options[:key_timestamp_field]
+        end
+        
       end
+      
+      
+      def self.validation_method_with_lifecycles(on)
+        if has_lifecycle? && self::Lifecycle.step_names.include?(on)
+          callback = :"validate_on_#{on}"
+          
+          # define these lifecycle validation callbacks on demand
+          define_callbacks callback unless respond_to? :callback
+          define_method(callback) {}
+          
+          callback
+        else
+          validation_method_without_lifecycles(on)
+        end
+      end
+      metaclass.alias_method_chain :validation_method, :lifecycles
+      
+      
+      def valid_with_lifecycles?
+        valid_without_lifecycles?
+        
+        if self.class.has_lifecycle? && (step = lifecycle.active_step) && respond_to?(cb = "validate_on_#{step.name}")
+          run_callbacks cb
+        end
 
-
-      def self.has_lifecycle?
-        defined?(self::Lifecycle)
+        errors.empty?
       end
+      alias_method_chain :valid?, :lifecycles
 
 
       def lifecycle
@@ -54,21 +87,22 @@ module Hobo
         @lifecycle = lifecycle
       end
 
-      def state(*names, &block)
-        names.map {|name| @lifecycle.def_state(name, block) }
-      end
-
-      def initial_state(name, &block)
-        s = @lifecycle.def_state(name, block)
-        @lifecycle.initial_state = s
+      def state(*args, &block)
+        options = args.extract_options!
+        names = args
+        states = names.map {|name| @lifecycle.def_state(name, block) }
+        if options[:default]
+          raise ArgumentError, "you must define one state if you give the :default option" unless states.length == 1
+          @lifecycle.default_state = states.first
+        end
       end
 
-      def create(who, name, options={}, &block)
-        @lifecycle.def_creator(name, who, block, options)
+      def create(name, options={}, &block)
+        @lifecycle.def_creator(name, block, options)
       end
 
-      def transition(who, name, change, options={}, &block)
-        @lifecycle.def_transition(name, who,
+      def transition(name, change, options={}, &block)
+        @lifecycle.def_transition(name,
                                   Array(change.keys.first), change.values.first,
                                   block, options)
       end
@@ -77,10 +111,6 @@ module Hobo
         @lifecycle.invariants << block
       end
 
-      def precondition(&block)
-        @lifecycle.preconditions << block
-      end
-
     end
 
   end