brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold.rb

@@ -3,6 +3,7 @@ module ActiveScaffold
   class DependencyFailure < RuntimeError; end
   class MalformedConstraint < RuntimeError; end
   class RecordNotAllowed < SecurityError; end
+  class ActionNotAllowed < SecurityError; end
   class ReverseAssociationRequired < RuntimeError; end
 
   def self.included(base)
@@ -54,18 +55,15 @@ module ActiveScaffold
 
       # run the configuration
       @active_scaffold_config = ActiveScaffold::Config::Core.new(model_id)
-      self.active_scaffold_config.configure &block if block_given?
-      self.active_scaffold_config._load_action_columns
-
-      # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
-      klass = self.active_scaffold_config.model
-      klass.define_attribute_methods unless klass.generated_methods?
+      @active_scaffold_config_block = block
+      self.links_for_associations
 
       @active_scaffold_overrides = []
       ActionController::Base.view_paths.each do |dir|
         active_scaffold_overrides_dir = File.join(dir,"active_scaffold_overrides")
         @active_scaffold_overrides << active_scaffold_overrides_dir if File.exists?(active_scaffold_overrides_dir)
       end
+      @active_scaffold_overrides.uniq! # Fix rails duplicating some view_paths
       @active_scaffold_frontends = []
       if active_scaffold_config.frontend.to_sym != :default
         active_scaffold_custom_frontend_path = File.join(Rails.root, 'vendor', 'plugins', ActiveScaffold::Config::Core.plugin_directory, 'frontends', active_scaffold_config.frontend.to_s , 'views')
@@ -73,6 +71,16 @@ module ActiveScaffold
       end
       active_scaffold_default_frontend_path = File.join(Rails.root, 'vendor', 'plugins', ActiveScaffold::Config::Core.plugin_directory, 'frontends', 'default' , 'views')
       @active_scaffold_frontends << active_scaffold_default_frontend_path
+      @active_scaffold_custom_paths = []
+
+      self.active_scaffold_superclasses_blocks.each {|superblock| self.active_scaffold_config.configure &superblock}
+      self.active_scaffold_config.configure &block if block_given?
+      self.active_scaffold_config._configure_sti unless self.active_scaffold_config.sti_children.nil?
+      self.active_scaffold_config._load_action_columns
+
+      # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
+      klass = self.active_scaffold_config.model
+      klass.define_attribute_methods unless klass.generated_methods?
 
       # include the rest of the code into the controller: the action core and the included actions
       module_eval do
@@ -82,7 +90,7 @@ module ActiveScaffold
         include ActiveScaffold::Actions::Core
         active_scaffold_config.actions.each do |mod|
           name = mod.to_s.camelize
-          include "ActiveScaffold::Actions::#{name}".constantize rescue nil
+          include "ActiveScaffold::Actions::#{name}".constantize
 
           # sneak the action links from the actions into the main set
           if link = active_scaffold_config.send(mod).link rescue nil
@@ -90,14 +98,77 @@ module ActiveScaffold
           end
         end
       end
+      self.active_scaffold_config._add_sti_create_links if self.active_scaffold_config.add_sti_create_links?
+    end
+
+    # Create the automatic column links. Note that this has to happen when configuration is *done*, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn't it?
+    def links_for_associations
+      return unless active_scaffold_config.actions.include? :list and active_scaffold_config.actions.include? :nested
+      active_scaffold_config.columns.each do |column|
+        next unless column.link.nil? and column.autolink?
+        if column.plural_association?
+          # note: we can't create nested scaffolds on :through associations because there's no reverse association.
+          column.set_link('nested', :parameters => {:associations => column.name.to_sym}, :html_options => {:class => column.name}) #unless column.through_association?
+        elsif column.polymorphic_association?
+          # note: we can't create inline forms on singular polymorphic associations
+          column.clear_link
+        else
+          model = column.association.klass
+          begin
+            controller = active_scaffold_controller_for(model)
+          rescue ActiveScaffold::ControllerNotFound
+            next
+          end
+
+          actions = controller.active_scaffold_config.actions
+          column.actions_for_association_links.delete :new unless actions.include? :create
+          column.actions_for_association_links.delete :edit unless actions.include? :update
+          column.actions_for_association_links.delete :show unless actions.include? :show
+          column.set_link(:none, :controller => controller.controller_path, :crud_type => nil, :label => :create_model, :html_options => {:class => column.name})
+        end
+      end
+    end
+
+    def add_active_scaffold_path(path)
+      @active_scaffold_paths = nil # Force active_scaffold_paths to rebuild
+      @active_scaffold_custom_paths << path
+    end
+
+    def add_active_scaffold_override_path(path)
+      @active_scaffold_paths = nil # Force active_scaffold_paths to rebuild
+      @active_scaffold_overrides.unshift path
     end
 
     def active_scaffold_paths
-      @active_scaffold_paths ||= ActionView::PathSet.new(@active_scaffold_overrides + @active_scaffold_frontends) unless @active_scaffold_overrides.nil? || @active_scaffold_frontends.nil?
+      return @active_scaffold_paths unless @active_scaffold_paths.nil?
+
+      @active_scaffold_paths = ActionView::PathSet.new
+      @active_scaffold_paths.concat @active_scaffold_overrides unless @active_scaffold_overrides.nil?
+      @active_scaffold_paths.concat @active_scaffold_custom_paths unless @active_scaffold_custom_paths.nil?
+      @active_scaffold_paths.concat @active_scaffold_frontends unless @active_scaffold_frontends.nil?
+      @active_scaffold_paths
     end
 
     def active_scaffold_config
-       @active_scaffold_config || self.superclass.instance_variable_get('@active_scaffold_config')
+      if @active_scaffold_config.nil?
+        self.superclass.active_scaffold_config if self.superclass.respond_to? :active_scaffold_config
+      else
+        @active_scaffold_config
+      end
+    end
+
+    def active_scaffold_config_block
+      @active_scaffold_config_block
+    end
+
+    def active_scaffold_superclasses_blocks
+      blocks = []
+      klass = self.superclass
+      while klass.respond_to? :active_scaffold_superclasses_blocks
+        blocks << klass.active_scaffold_config_block
+        klass = klass.superclass
+      end
+      blocks.compact.reverse
     end
 
     def active_scaffold_config_for(klass)
@@ -116,23 +187,25 @@ module ActiveScaffold
     # Searches in the namespace of the current controller for singular and plural versions of the conventional "#{model}Controller" syntax.
     # You may override this method to customize the search routine.
     def active_scaffold_controller_for(klass)
-      namespace = self.to_s.split('::')[0...-1].join('::') + '::'
+      controller_namespace = self.to_s.split('::')[0...-1].join('::') + '::'
       error_message = []
-      ["#{klass.to_s.underscore.pluralize}", "#{klass.to_s.underscore.pluralize.singularize}"].each do |controller_name|
-        begin
-          controller = "#{namespace}#{controller_name.camelize}Controller".constantize
-        rescue NameError => error
-          # Only rescue NameError associated with the controller constant not existing - not other compile errors
-          if error.message["uninitialized constant #{controller}"]
-            error_message << "#{namespace}#{controller_name.camelize}Controller"
-            next
-          else
-            raise
+      [controller_namespace, ''].each do |namespace|
+        ["#{klass.to_s.underscore.pluralize}", "#{klass.to_s.underscore.pluralize.singularize}"].each do |controller_name|
+          begin
+            controller = "#{namespace}#{controller_name.camelize}Controller".constantize
+          rescue NameError => error
+            # Only rescue NameError associated with the controller constant not existing - not other compile errors
+            if error.message["uninitialized constant #{controller}"]
+              error_message << "#{namespace}#{controller_name.camelize}Controller"
+              next
+            else
+              raise
+            end
           end
+          raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
+          raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller unless controller.active_scaffold_config.model.to_s == klass.to_s
+          return controller
         end
-        raise ActiveScaffold::ControllerNotFound, "#{controller} missing ActiveScaffold", caller unless controller.uses_active_scaffold?
-        raise ActiveScaffold::ControllerNotFound, "ActiveScaffold on #{controller} is not for #{klass} model.", caller unless controller.active_scaffold_config.model == klass
-        return controller
       end
       raise ActiveScaffold::ControllerNotFound, "Could not find " + error_message.join(" or "), caller
     end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/common_search.rb

@@ -0,0 +1,18 @@
+module ActiveScaffold::Actions
+  module CommonSearch
+    protected
+    def store_search_params_into_session
+      active_scaffold_session_storage[:search] = params.delete :search if params[:search]
+    end
+    
+    def search_params
+      active_scaffold_session_storage[:search]
+    end
+
+    # The default security delegates to ActiveRecordPermissions.
+    # You may override the method to customize.
+    def search_authorized?
+      authorized_for?(:crud_type => :read)
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/core.rb

@@ -1,102 +1,152 @@
-module ActiveScaffold::Actions
-  module Core
-    def self.included(base)
-      base.class_eval do
-        after_filter :clear_flashes
-      end
-    end
-
-    protected
-
-    def authorized_for?(*args)
-      active_scaffold_config.model.authorized_for?(*args)
-    end
-
-    def clear_flashes
-      if request.xhr?
-        flash.keys.each do |flash_key|
-          flash[flash_key] = nil
-        end
-      end
-    end
-
-    # Returns true if the client accepts one of the MIME types passed to it
-    # ex: accepts? :html, :xml
-    def accepts?(*types)
-      for priority in request.accepts.compact
-        if priority == Mime::ALL
-          # Because IE always sends */* in the accepts header and we assume
-          # that if you really wanted XML or something else you would say so
-          # explicitly, we will assume */* to only ask for :html
-          return types.include?(:html)
-        elsif types.include?(priority.to_sym)
-          return true
-        end
-      end
-      false
-    end
-
-    def response_status
-      successful? ? 200 : 500
-    end
-
-    # API response object that will be converted to XML/YAML/JSON using to_xxx
-    def response_object
-      @response_object = successful? ? (@record || @records) : @record.errors
-    end
-
-    # Success is the existence of certain variables and the absence of errors (when applicable).
-    # Success can also be defined.
-    def successful?
-      if @successful.nil?
-        @records or (@record and @record.errors.count == 0 and @record.no_errors_in_associated?)
-      else
-        @successful
-      end
-    end
-
-    def successful=(val)
-      @successful = (val) ? true : false
-    end
-
-    # Redirect to the main page (override if the ActiveScaffold is used as a component on another controllers page) for Javascript degradation
-    def return_to_main
-      unless params[:parent_controller].nil?
-        params[:controller] = params[:parent_controller]
-        params[:eid] = nil
-        params[:parent_model] = nil
-        params[:parent_column] = nil
-        params[:parent_id] = nil
-      end
-      redirect_to params_for(:action => "index")
-    end
-
-    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
-    def conditions_for_collection
-    end
-  
-    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
-    def joins_for_collection
-    end
-  
-    # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
-    def custom_finder_options
-      {}
-    end
-  
-
-    # Builds search conditions by search params for column names. This allows urls like "contacts/list?company_id=5".
-    def conditions_from_params
-      conditions = nil
-      params.reject {|key, value| [:controller, :action, :id].include?(key.to_sym)}.each do |key, value|
-        next unless active_scaffold_config.model.column_names.include?(key)
-        if value.is_a?(Array)
-          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} in (?)", value])
-        else
-          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} = ?", value])
-        end
-      end
-      conditions
-    end
-  end
-end
+module ActiveScaffold::Actions
+  module Core
+    def self.included(base)
+      base.class_eval do
+        after_filter :clear_flashes
+      end
+    end
+    def render_field
+      @record = if params[:in_place_editing]
+        active_scaffold_config.model.find params[:id]
+      else
+        active_scaffold_config.model.new
+      end
+      column = active_scaffold_config.columns[params[:column]]
+      if params[:in_place_editing]
+        render :inline => "<%= active_scaffold_input_for(active_scaffold_config.columns[params[:update_column].to_sym]) %>"
+      elsif !column.nil?
+        if column.send_form_on_update_column
+          @record = update_record_from_params(@record, active_scaffold_config.update.columns, params[:record])
+        else
+          value = column_value_from_param_value(@record, column, params[:value])
+          @record.send "#{column.name}=", value
+        end
+        @update_columns = Array(params[:update_column])
+        after_render_field(@record, column)
+      end
+    end
+
+    protected
+    
+    # override this method if you want to do something after render_field
+    def after_render_field(record, column); end
+
+    def authorized_for?(options = {})
+      active_scaffold_config.model.authorized_for?(options)
+    end
+
+    def clear_flashes
+      if request.xhr?
+        flash.keys.each do |flash_key|
+          flash[flash_key] = nil
+        end
+      end
+    end
+
+    def marked_records
+      active_scaffold_session_storage[:marked_records] ||= Set.new
+    end
+    
+    def default_formats
+      [:html, :js, :json, :xml, :yaml]
+    end
+    # Returns true if the client accepts one of the MIME types passed to it
+    # ex: accepts? :html, :xml
+    def accepts?(*types)
+      for priority in request.accepts.compact
+        if priority == Mime::ALL
+          # Because IE always sends */* in the accepts header and we assume
+          # that if you really wanted XML or something else you would say so
+          # explicitly, we will assume */* to only ask for :html
+          return types.include?(:html)
+        elsif types.include?(priority.to_sym)
+          return true
+        end
+      end
+      false
+    end
+
+    def response_status
+      if successful?
+        action_name == 'create' ? 201 : 200
+      else
+        422
+      end
+    end
+
+    # API response object that will be converted to XML/YAML/JSON using to_xxx
+    def response_object
+      @response_object = successful? ? (@record || @records) : @record.errors
+    end
+
+    # Success is the existence of certain variables and the absence of errors (when applicable).
+    # Success can also be defined.
+    def successful?
+      if @successful.nil?
+        @records or (@record and @record.errors.count == 0 and @record.no_errors_in_associated?)
+      else
+        @successful
+      end
+    end
+
+    def successful=(val)
+      @successful = (val) ? true : false
+    end
+
+    # Redirect to the main page (override if the ActiveScaffold is used as a component on another controllers page) for Javascript degradation
+    def return_to_main
+      redirect_to main_path_to_return
+    end
+
+    # Override this method on your controller to define conditions to be used when querying a recordset (e.g. for List). The return of this method should be any format compatible with the :conditions clause of ActiveRecord::Base's find.
+    def conditions_for_collection
+    end
+  
+    # Override this method on your controller to define joins to be used when querying a recordset (e.g. for List).  The return of this method should be any format compatible with the :joins clause of ActiveRecord::Base's find.
+    def joins_for_collection
+    end
+  
+    # Override this method on your controller to provide custom finder options to the find() call. The return of this method should be a hash.
+    def custom_finder_options
+      {}
+    end
+  
+    #Overide this method on your controller to provide model with named scopes
+    def beginning_of_chain
+      active_scaffold_config.model
+    end
+        
+    # Builds search conditions by search params for column names. This allows urls like "contacts/list?company_id=5".
+    def conditions_from_params
+      conditions = nil
+      params.reject {|key, value| [:controller, :action, :id, :page, :sort, :sort_direction].include?(key.to_sym)}.each do |key, value|
+        next unless active_scaffold_config.model.column_names.include?(key)
+        if value.is_a?(Array)
+          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} in (?)", value])
+        else
+          conditions = merge_conditions(conditions, ["#{active_scaffold_config.model.table_name}.#{key.to_s} = ?", value])
+        end
+      end
+      conditions
+    end
+    private
+    def respond_to_action(action)
+      respond_to do |type|
+        send("#{action}_formats").each do |format|
+          type.send(format){ send("#{action}_respond_to_#{format}") }
+        end
+      end
+    end
+
+    def response_code_for_rescue(exception)
+      case exception
+        when ActiveScaffold::RecordNotAllowed
+          "403 Record Not Allowed"
+        when ActiveScaffold::ActionNotAllowed
+          "403 Action Not Allowed"
+        else
+          super
+      end
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/actions/create.rb

@@ -1,7 +1,7 @@
 module ActiveScaffold::Actions
   module Create
     def self.included(base)
-      base.before_filter :create_authorized?, :only => [:new, :create]
+      base.before_filter :create_authorized_filter, :only => [:new, :create]
       base.prepend_before_filter :constraints_for_nested_create, :only => [:new, :create]
       base.verify :method => :post,
                   :only => :create,
@@ -10,63 +10,74 @@ module ActiveScaffold::Actions
 
     def new
       do_new
-
-      respond_to do |type|
-        type.html do
-          if successful?
-            render(:action => 'create')
-          else
-            return_to_main
-          end
-        end
-        type.js do
-          render(:partial => 'create_form')
-        end
-      end
+      respond_to_action(:new)
     end
 
     def create
       do_create
       @insert_row = params[:parent_controller].nil?
+      respond_to_action(:create)
+    end
 
-      respond_to do |type|
-        type.html do
-          if params[:iframe]=='true' # was this an iframe post ?
-            responds_to_parent do
-              if successful?
-                render :action => 'on_create'
-              else
-                render :action => 'form_messages_on_create'
-              end
-            end
+    protected
+    def response_location
+      url_for(params_for(:action => "show", :id => @record.id)) if successful?
+    end
+
+    def new_respond_to_html
+      if successful?
+        render(:action => 'create')
+      else
+        return_to_main
+      end
+    end
+    
+    def new_respond_to_js
+      render(:partial => 'create_form')
+    end
+
+    def create_respond_to_html
+      if params[:iframe]=='true' # was this an iframe post ?
+        responds_to_parent do
+          render :action => 'on_create.js'
+        end
+      else
+        if successful?
+          flash[:info] = as_(:created_model, :model => @record.to_label)
+          if action = active_scaffold_config.create.action_after_create
+            redirect_to params_for(:action => action, :id => @record.id)
+          elsif active_scaffold_config.create.persistent
+            redirect_to params_for(:action => "new")
+          else
+            return_to_main
+          end
+        else
+          if params[:nested].nil? && active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.always_show_create
+            do_list
+            render(:action => 'list')
           else
-            if successful?
-              flash[:info] = as_(:created_model, :model => @record.to_label)
-              if active_scaffold_config.create.edit_after_create
-                redirect_to params.merge(:action => "edit", :id => @record.id)
-              else
-                return_to_main
-              end
-            else
-              if params[:nested].nil? && active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.always_show_create
-                do_list
-                render(:action => 'list')
-              else
-                render(:action => 'create')
-              end
-            end
+            render(:action => 'create')
           end
         end
-        type.js do
-          render :action => 'on_create'
-        end
-        type.xml { render :xml => response_object.to_xml, :content_type => Mime::XML, :status => response_status }
-        type.json { render :text => response_object.to_json, :content_type => Mime::JSON, :status => response_status }
-        type.yaml { render :text => response_object.to_yaml, :content_type => Mime::YAML, :status => response_status }
       end
     end
 
-    protected
+    def create_respond_to_js
+      render :action => 'on_create'
+    end
+
+    def create_respond_to_xml
+      render :xml => response_object.to_xml(:only => active_scaffold_config.create.columns.names), :content_type => Mime::XML, :status => response_status, :location => response_location
+    end
+
+    def create_respond_to_json
+      render :text => response_object.to_json(:only => active_scaffold_config.create.columns.names), :content_type => Mime::JSON, :status => response_status, :location => response_location
+    end
+
+    def create_respond_to_yaml
+      render :text => Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.create.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status, :location => response_location
+    end
+
     def constraints_for_nested_create
       if params[:parent_column] && params[:parent_id]
         @old_eid = params[:eid]
@@ -80,7 +91,7 @@ module ActiveScaffold::Actions
     # A simple method to find and prepare an example new record for the form
     # May be overridden to customize the behavior (add default values, for instance)
     def do_new
-      @record = active_scaffold_config.model.new
+      @record = new_model
       apply_constraints_to_record(@record)
       params[:eid] = @old_eid if @remove_eid
       @record
@@ -91,7 +102,7 @@ module ActiveScaffold::Actions
     def do_create
       begin
         active_scaffold_config.model.transaction do
-          @record = update_record_from_params(active_scaffold_config.model.new, active_scaffold_config.create.columns, params[:record])
+          @record = update_record_from_params(new_model, active_scaffold_config.create.columns, params[:record])
           apply_constraints_to_record(@record, :allow_autosave => true)
           params[:eid] = @old_eid if @remove_eid
           before_create_save(@record)
@@ -105,6 +116,16 @@ module ActiveScaffold::Actions
       end
     end
 
+    def new_model
+      model = active_scaffold_config.model
+      if model.columns_hash[model.inheritance_column]
+        params = self.params # in new action inheritance_column must be in params
+        params = params[:record] || {} unless params[model.inheritance_column] # in create action must be inside record key
+        model = params.delete(model.inheritance_column).camelize.constantize if params[model.inheritance_column]
+      end
+      model.new
+    end
+
     # override this method if you want to inject data in the record (or its associated objects) before the save
     def before_create_save(record); end
 
@@ -114,7 +135,18 @@ module ActiveScaffold::Actions
     # The default security delegates to ActiveRecordPermissions.
     # You may override the method to customize.
     def create_authorized?
-      authorized_for?(:action => :create)
+      authorized_for?(:crud_type => :create)
+    end
+    private
+    def create_authorized_filter
+      link = active_scaffold_config.create.link || active_scaffold_config.create.class.link
+      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
+    end
+    def new_formats
+      (default_formats + active_scaffold_config.formats).uniq
+    end
+    def create_formats
+      (default_formats + active_scaffold_config.formats + active_scaffold_config.create.formats).uniq
     end
   end
 end