active_scaffold 3.2.17 → 3.2.18

data/lib/active_scaffold/actions/common_search.rb

@@ -1,22 +0,0 @@
-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
-
-    def search_ignore?
-      active_scaffold_config.list.always_show_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/lib/active_scaffold/actions/core.rb

@@ -1,203 +0,0 @@
-module ActiveScaffold::Actions
-  module Core
-    def self.included(base)
-      base.class_eval do
-        prepend_before_filter :register_constraints_with_action_columns, :unless => :nested?
-        after_filter :clear_flashes
-        rescue_from ActiveScaffold::RecordNotAllowed, ActiveScaffold::ActionNotAllowed, :with => :deny_access
-      end
-      base.helper_method :nested?
-      base.helper_method :calculate
-      base.helper_method :new_model
-    end
-    def render_field
-      if params[:in_place_editing]
-        render_field_for_inplace_editing
-      else
-        render_field_for_update_columns
-      end
-    end
-    
-    protected
-    def embedded?
-      @embedded ||= params.delete(:embedded)
-    end
-
-    def nested?
-      false
-    end
-
-    def render_field_for_inplace_editing
-      @record = find_if_allowed(params[:id], :update)
-      render :inline => "<%= active_scaffold_input_for(active_scaffold_config.columns[params[:update_column].to_sym]) %>"
-    end
-
-    def render_field_for_update_columns
-      column = active_scaffold_config.columns[params[:column]]
-      unless column.nil?
-        @source_id = params.delete(:source_id)
-        @columns = column.update_columns
-        @scope = params[:scope]
-        
-        if column.send_form_on_update_column
-          if @scope
-            hash = @scope.gsub('[','').split(']').inject(params[:record]) do |hash, index|
-              hash[index]
-            end
-            id = hash[:id]
-          else
-            hash = params[:record]
-            id = params[:id]
-          end
-          @record = id ? find_if_allowed(id, :update) : new_model
-          @record = update_record_from_params(@record, active_scaffold_config.send(@scope ? :subform : (id ? :update : :create)).columns, hash)
-        else
-          @record = new_model
-          value = column_value_from_param_value(@record, column, params[:value])
-          @record.send "#{column.name}=", value
-        end
-        
-        after_render_field(@record, column)
-      end
-    end
-    
-    # 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 each_marked_record(&block)
-      active_scaffold_config.model.find(marked_records.to_a).each &block
-    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 one or more model objects. Most actions
-    # circumvent this method by setting @success directly.
-    def successful?
-      if @successful.nil?
-        @record || @records
-      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_from_params ||= begin
-        conditions = {}
-        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.columns_hash[key.to_s]
-          next if active_scaffold_constraints[key.to_sym]
-          next if nested? and nested.constrained_fields.include? key.to_sym
-          conditions[key.to_sym] = value
-        end
-        conditions
-      end
-    end
-
-    def new_model
-      model = beginning_of_chain
-      if nested? && nested.association && nested.association.collection? && model.columns_hash[column = model.inheritance_column]
-        model_name = params.delete(column) # in new action inheritance_column must be in params
-        model_name ||= params[:record].delete(column) unless params[:record].blank? # in create action must be inside record key
-        model_name = model_name.camelize if model_name
-        model_name ||= active_scaffold_config.model.name
-        build_options = {column.to_sym => model_name} if model_name
-      end
-      model.respond_to?(:build) ? model.build(build_options || {}) : model.new
-    end
-
-    private
-    def respond_to_action(action)
-      respond_to do |type|
-        action_formats.each do |format|
-          type.send(format) do
-            if respond_to?(method_name = "#{action}_respond_to_#{format}")
-              send(method_name)
-            end
-          end
-        end
-      end
-    end
-
-    def action_formats
-      @action_formats ||= if respond_to? "#{action_name}_formats", true
-        send("#{action_name}_formats")
-      else
-        (default_formats + active_scaffold_config.formats).uniq
-      end
-    end
-  end
-end

data/lib/active_scaffold/actions/create.rb

@@ -1,139 +0,0 @@
-module ActiveScaffold::Actions
-  module Create
-    def self.included(base)
-      base.before_filter :create_authorized_filter, :only => [:new, :create]
-    end
-
-    def new
-      do_new
-      respond_to_action(:new)
-    end
-
-    def create
-      do_create
-      respond_to_action(:create)
-    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', :formats => [:js], :layout => false
-        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 !nested? && active_scaffold_config.actions.include?(:list) && active_scaffold_config.list.always_show_create
-            list
-          else
-            render(:action => 'create')
-          end
-        end
-      end
-    end
-
-    def create_respond_to_js
-      do_refresh_list if successful? && active_scaffold_config.create.refresh_list && !render_parent?
-      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
-
-    # 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 = new_model
-      apply_constraints_to_record(@record)
-      create_association_with_parent(@record) if nested?
-      @record
-    end
-
-    # A somewhat complex method to actually create a new record. The complexity is from support for subforms and associated records.
-    # If you want to customize this behavior, consider using the +before_create_save+ and +after_create_save+ callbacks.
-    def do_create(options = {})
-      attributes = options[:attributes] || params[:record]
-      begin
-        active_scaffold_config.model.transaction do
-          @record = update_record_from_params(new_model, active_scaffold_config.create.columns, attributes)
-          apply_constraints_to_record(@record, :allow_autosave => true)
-          create_association_with_parent(@record) if nested?
-          before_create_save(@record)
-          self.successful = [@record.valid?, @record.associated_valid?].all? {|v| v == true} # this syntax avoids a short-circuit
-          create_save(@record) unless options[:skip_save]
-        end
-      rescue ActiveRecord::ActiveRecordError => ex
-        flash[:error] = ex.message
-        self.successful = false
-      end
-    end
-
-    def create_save(record)
-      if successful?
-        record.save! and record.save_associated!
-        after_create_save(record)
-      end
-    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
-
-    # override this method if you want to do something after the save
-    def after_create_save(record); end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    
-    def create_ignore?
-      nested? && active_scaffold_config.list.always_show_create
-    end
-    
-    def create_authorized?
-      (!nested? || !nested.readonly? || !nested.through?) && 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

data/lib/active_scaffold/actions/delete.rb

@@ -1,74 +0,0 @@
-module ActiveScaffold::Actions
-  module Delete
-    def self.included(base)
-      base.before_filter :delete_authorized_filter, :only => [:destroy]
-    end
-
-    def destroy
-      params.delete :destroy_action
-      process_action_link_action(:destroy) do |record|
-        do_destroy
-      end
-    end
-
-    protected
-    def destroy_respond_to_html
-      if self.successful?
-        flash[:info] = as_(:deleted_model, :model => @record.to_label)
-      else
-        #error_message_for not available in controller...
-        #flash[:error] = active_scaffold_error_messages_for(@record, :object_name => "#{@record.class.model_name.human.downcase}#{@record.new_record? ? '' : ": #{@record.to_label}"}", :header_message => '', :message => "#{@record.class.model_name.human.downcase}#{@record.new_record? ? '' : ": #{@record.to_label}"}", :container_tag => nil, :list_type => :br)
-      end
-      return_to_main
-    end
-
-    def destroy_respond_to_js
-      do_refresh_list if successful? && active_scaffold_config.delete.refresh_list && !render_parent?
-      render(:action => 'destroy')
-    end
-
-    def destroy_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml(:only => active_scaffold_config.list.columns.names), :content_type => Mime::XML, :status => response_status
-    end
-
-    def destroy_respond_to_json
-      render :text => successful? ? "" : response_object.to_json(:only => active_scaffold_config.list.columns.names), :content_type => Mime::JSON, :status => response_status
-    end
-
-    def destroy_respond_to_yaml
-      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => active_scaffold_config.list.columns.names)).to_yaml, :content_type => Mime::YAML, :status => response_status
-    end
-
-    def destroy_find_record
-      @record = find_if_allowed(params[:id], :delete)
-    end
-
-    # A simple method to handle the actual destroying of a record
-    # May be overridden to customize the behavior
-    def do_destroy
-      @record ||= destroy_find_record
-      begin
-        self.successful = @record.destroy
-      rescue Exception => ex
-        flash[:warning] = as_(:cant_destroy_record, :record => @record.to_label)
-        self.successful = false
-        logger.debug ex.message
-        logger.debug ex.backtrace.join("\n")
-      end
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def delete_authorized?(record = nil)
-      (!nested? || !nested.readonly?) && (record || self).send(:authorized_for?, :crud_type => :delete)
-    end
-    private
-    def delete_authorized_filter
-      link = active_scaffold_config.delete.link || active_scaffold_config.delete.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
-    end
-    def destroy_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.delete.formats).uniq
-    end
-  end
-end

data/lib/active_scaffold/actions/field_search.rb

@@ -1,78 +0,0 @@
-module ActiveScaffold::Actions
-  module FieldSearch
-    include ActiveScaffold::Actions::CommonSearch
-    def self.included(base)
-      base.before_filter :search_authorized_filter, :only => :show_search
-      base.before_filter :store_search_params_into_session, :only => [:index]
-      base.before_filter :do_search, :only => [:index]
-      base.helper_method :field_search_params
-    end
-
-    # FieldSearch uses params[:search] and not @record because search conditions do not always pass the Model's validations.
-    # This facilitates for example, textual searches against associations via .search_sql
-    def show_search
-      @record = new_model
-      respond_to_action(:field_search)
-    end
-
-    protected
-    
-    def store_search_params_into_session
-      set_field_search_default_params(active_scaffold_config.field_search.default_params) unless active_scaffold_config.field_search.default_params.nil?
-      super
-      active_scaffold_session_storage[:search] = nil if search_params.is_a?(String)
-    end
-    
-    def set_field_search_default_params(default_params)
-      if (params[:search].nil? && search_params.nil?) || (params[:search].is_a?(String) && params[:search].blank?)
-        params[:search] = default_params.is_a?(Proc) ? self.instance_eval(&default_params) : default_params
-      end
-    end
-    
-    def field_search_params
-      search_params || {}
-    end
-
-    def field_search_respond_to_html
-      render(:action => "field_search")
-    end
-    
-    def field_search_respond_to_js
-      render(:partial => "field_search")
-    end
-
-    def do_search
-      unless search_params.blank?
-        filtered_columns = []
-        text_search = active_scaffold_config.field_search.text_search
-        columns = active_scaffold_config.field_search.columns
-        search_params.each do |key, value|
-          next unless columns.include? key
-          search_condition = self.class.condition_for_column(active_scaffold_config.columns[key], value, text_search)
-          unless search_condition.blank?
-            self.active_scaffold_conditions << search_condition
-            filtered_columns << active_scaffold_config.columns[key]
-          end
-        end
-        unless filtered_columns.blank?
-          @filtered = active_scaffold_config.field_search.human_conditions ? filtered_columns : true
-        end
-
-        includes_for_search_columns = columns.collect{ |column| column.includes}.flatten.uniq.compact
-        self.active_scaffold_includes.concat includes_for_search_columns
-
-        active_scaffold_config.list.user.page = nil
-      end
-    end
-
-    private
-    
-    def search_authorized_filter
-      link = active_scaffold_config.field_search.link || active_scaffold_config.field_search.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
-    end
-    def field_search_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.field_search.formats).uniq
-    end
-  end
-end