active_scaffold 3.1.20 → 3.2.0

data/lib/active_scaffold/actions/core.rb~

@@ -1,203 +0,0 @@
-module ActiveScaffold::Actions
-  module Core
-    def self.included(base)
-      base.class_eval do
-        after_filter :clean_up_session
-        after_filter :clear_flashes
-      end
-      base.helper_method :nested?
-      base.helper_method :beginning_of_chain
-      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 clean_up_session
-      backup = session.reject! { |k, v| k.is_a?(String) && v != active_scaffold_session_storage && k.start_with?('as:')}
-    end
-
-    def nested?
-      false
-    end
-
-    def render_field_for_inplace_editing
-      register_constraints_with_action_columns(nested.constrained_fields, active_scaffold_config.update.hide_nested_column ? [] : [:update]) if nested?
-      @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
-          hash = if @scope
-            @scope.gsub('[','').split(']').inject(params[:record]) do |hash, index|
-              hash[index]
-            end
-          else
-            params[:record]
-          end
-          @record = hash[:id] ? find_if_allowed(hash[:id], :update) : new_model
-          @record = update_record_from_params(@record, active_scaffold_config.send(@scope ? :subform : (params[: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 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
-
-    def new_model
-      model = beginning_of_chain
-      if model.columns_hash[model.inheritance_column]
-        build_options = {model.inheritance_column.to_sym => active_scaffold_config.model_id} if nested? && nested.association && nested.association.collection?
-        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.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){ send("#{action}_respond_to_#{format}") }
-        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
-
-    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/lib/active_scaffold/actions/create.rb~

@@ -1,148 +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.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
-            do_list
-            render(:action => 'list')
-          else
-            render(:action => 'create')
-          end
-        end
-      end
-    end
-
-    def create_respond_to_js
-      if successful? && active_scaffold_config.create.refresh_list && !render_parent?
-        do_search if respond_to? :do_search
-        do_list
-      end
-      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)
-      if nested?
-        create_association_with_parent(@record)
-        register_constraints_with_action_columns(nested.constrained_fields)
-      end
-      @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
-      begin
-        active_scaffold_config.model.transaction do
-          @record = update_record_from_params(new_model, active_scaffold_config.create.columns, params[:record])
-          apply_constraints_to_record(@record, :allow_autosave => true)
-          if nested?
-            create_association_with_parent(@record) 
-            register_constraints_with_action_columns(nested.constrained_fields)
-          end
-          create_save
-        end
-      rescue ActiveRecord::RecordInvalid
-        self.successful = false
-        flash[:error] = $!.messages
-      end
-    end
-
-    def create_save
-      before_create_save(@record)
-      self.successful = [@record.valid?, @record.associated_valid?].all? {|v| v == true} # this syntax avoids a short-circuit
-      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?) && 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/list.rb~

@@ -1,196 +0,0 @@
-module ActiveScaffold::Actions
-  module List
-    def self.included(base)
-      base.before_filter :list_authorized_filter, :only => [:index, :row]
-      base.helper_method :list_columns
-    end
-
-    def index
-      list
-    end
-
-    # get just a single row
-    def row
-      @record = find_if_allowed(params[:id], :read)
-      respond_to_action(:row)
-    end
-
-    def list
-      do_list
-      @nested_auto_open = active_scaffold_config.list.nested_auto_open
-      respond_to_action(:list)
-    end
-    
-    protected
-    def list_respond_to_html
-      if params.delete(:embedded)
-        render :action => 'list', :layout => false
-      else
-        render :action => 'list'
-      end
-    end
-    def list_respond_to_js
-      if params[:adapter]
-        render(:partial => 'list_with_header')
-      elsif params[:embedded]
-        params.delete(:embedded)
-        render(:partial => 'list_with_header')
-      else
-        render :action => 'list.js'
-      end
-    end
-    def list_respond_to_xml
-      render :xml => response_object.to_xml(:only => list_columns_names), :content_type => Mime::XML, :status => response_status
-    end
-    def list_respond_to_json
-      render :text => response_object.to_json(:only => list_columns_names), :content_type => Mime::JSON, :status => response_status
-    end
-    def list_respond_to_yaml
-      render :text => Hash.from_xml(response_object.to_xml(:only => list_columns_names)).to_yaml, :content_type => Mime::YAML, :status => response_status
-    end
-    
-    def row_respond_to_html
-      render(:partial => 'row', :locals => {:record => @record})
-    end
-
-    # The actual algorithm to prepare for the list view
-    def set_includes_for_list_columns
-      includes_for_list_columns = active_scaffold_config.list.columns.collect{ |c| c.includes }.flatten.uniq.compact
-      self.active_scaffold_includes.concat includes_for_list_columns
-    end
-
-    # The actual algorithm to prepare for the list view
-    def do_list
-      set_includes_for_list_columns
-
-      options = { :sorting => active_scaffold_config.list.user.sorting,
-        :count_includes => active_scaffold_config.list.user.count_includes }
-      paginate = (params[:format].nil?) ? (accepts? :html, :js) : ['html', 'js'].include?(params[:format])
-      if paginate
-        options.merge!({
-            :per_page => active_scaffold_config.list.user.per_page,
-            :page => active_scaffold_config.list.user.page,
-            :pagination => active_scaffold_config.list.pagination
-          })
-      end
-
-      page = find_page(options)
-      if page.items.blank? && !page.pager.infinite?
-        page = page.pager.last
-        active_scaffold_config.list.user.page = page.number
-      end
-      @page, @records = page, page.items
-    end
-
-    def each_record_in_page
-      _page = active_scaffold_config.list.user.page
-      do_search if respond_to? :do_search
-      active_scaffold_config.list.user.page = _page
-      do_list
-      @page.items.each {|record| yield record}
-    end
-
-    def each_record_in_scope
-      do_search if respond_to? :do_search
-      finder_options = { :order => "#{active_scaffold_config.model.connection.quote_table_name(active_scaffold_config.model.table_name)}.#{active_scaffold_config.model.primary_key} ASC",
-        :conditions => all_conditions,
-        :joins => joins_for_finder}
-      finder_options.merge! custom_finder_options
-      finder_options.merge! :include => (active_scaffold_includes.blank? ? nil : active_scaffold_includes)
-      klass = beginning_of_chain
-      klass.all(finder_options).each {|record| yield record}
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def list_authorized?
-      authorized_for?(:crud_type => :read)
-    end
-
-    # call this method in your action_link action to simplify processing of actions
-    # eg for member action_link :fire
-    # process_action_link_action do |record|
-    #   record.update_attributes(:fired => true)
-    #   self.successful = true
-    #   flash[:info] = 'Player fired'
-    # end
-    def process_action_link_action(render_action = :action_update, crud_type = nil)
-      if request.get?
-        # someone has disabled javascript, we have to show confirmation form first
-        @record = find_if_allowed(params[:id], :read) if params[:id] && params[:id] && params[:id].to_i > 0
-        respond_to_action(:action_confirmation)
-      else
-        if params[:id] && params[:id] && params[:id].to_i > 0
-          crud_type ||= (request.post? || request.put?) ? :update : :delete
-          @record = find_if_allowed(params[:id], crud_type)
-          unless @record.nil?
-            yield @record
-          else
-            self.successful = false
-            flash[:error] = as_(:no_authorization_for_action, :action => action_name)
-          end
-        else
-          yield
-        end
-        respond_to_action(render_action)
-      end
-    end
-
-    def action_confirmation_respond_to_html(confirm_action = action_name.to_sym)
-      link = active_scaffold_config.action_links[confirm_action]
-      render :action => 'action_confirmation', :locals => {:record => @record, :link => link}
-    end
-
-    def action_update_respond_to_html
-      do_search if respond_to? :do_search
-      do_list
-      redirect_to :action => 'index'
-    end
-
-    def action_update_respond_to_js
-      render(:action => 'on_action_update')
-    end
-
-    def action_update_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml(:only => list_columns_names), :content_type => Mime::XML, :status => response_status
-    end
-
-    def action_update_respond_to_json
-      render :text => successful? ? "" : response_object.to_json(:only => list_columns_names), :content_type => Mime::JSON, :status => response_status
-    end
-
-    def action_update_respond_to_yaml
-      render :text => successful? ? "" : Hash.from_xml(response_object.to_xml(:only => list_columns_names)).to_yaml, :content_type => Mime::YAML, :status => response_status
-    end
-     
-    private
-    def list_authorized_filter
-      raise ActiveScaffold::ActionNotAllowed unless list_authorized?
-    end
-
-    def list_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
-    end
-    alias_method :index_formats, :list_formats
-
-    def row_formats
-      ([:html] + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
-    end
-
-    def action_update_formats
-      (default_formats + active_scaffold_config.formats).uniq
-    end
-
-    def action_confirmation_formats
-      (default_formats + active_scaffold_config.formats).uniq
-    end
-
-    def list_columns
-      active_scaffold_config.list.columns.collect_visible
-    end
-
-    def list_columns_names
-      list_columns.collect(&:name)
-    end
-  end
-end