lockbox_middleware 1.2.1 → 1.2.2

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

@@ -1,136 +0,0 @@
-module ActiveScaffold::Actions
-  module Core
-    def self.included(base)
-      base.class_eval do
-        after_filter :clear_flashes
-      end
-    end
-    def render_field
-      @record = active_scaffold_config.model.new
-      @update_columns = []
-      column = active_scaffold_config.columns[params[:column]]
-      unless column.nil?
-        value = if column.association
-          params[:value].blank? ? nil : column.association.klass.find(params[:value])
-        else
-          params[:value]
-        end
-        @record.send "#{column.name}=", value
-        @update_columns << Array(column.options[:update_column]).collect {|column_name| active_scaffold_config.columns[column_name]}
-        @update_columns.flatten!
-        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?(*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
-
-    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
-      successful? ? 200 : 422
-    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
-  
-
-    # 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,158 +0,0 @@
-module ActiveScaffold::Actions
-  module Create
-    def self.included(base)
-      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,
-                  :redirect_to => { :action => :index }
-    end
-
-    def new
-      do_new
-      respond_to_action(:new)
-    end
-
-    def create
-      do_create
-      @insert_row = params[:parent_controller].nil?
-      respond_to_action(:create)
-    end
-
-    protected
-    def response_status
-      successful? ? 201 : super
-    end
-
-    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
-          if successful?
-            render :action => 'on_create.js'
-          else
-            render :action => 'form_messages_on_create.js'
-          end
-        end
-      else
-        if successful?
-          flash[:info] = as_(:created_model, :model => @record.to_label)
-          if active_scaffold_config.create.edit_after_create
-            redirect_to params_for(: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
-      end
-    end
-
-    def create_respond_to_js
-      render :action => 'on_create'
-    end
-
-    def create_respond_to_xml
-      render :xml => response_object.to_xml, :content_type => Mime::XML, :status => response_status, :location => response_location
-    end
-
-    def create_respond_to_json
-      render :text => response_object.to_json, :content_type => Mime::JSON, :status => response_status, :location => response_location
-    end
-
-    def create_respond_to_yaml
-      render :text => response_object.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]
-        @remove_eid = true
-        constraints = {params[:parent_column].to_sym => params[:parent_id]}
-        params[:eid] = Digest::MD5.hexdigest(params[:parent_controller] + params[:controller].to_s + constraints.to_s)
-        session["as:#{params[:eid]}"] = {:constraints => constraints}
-      end
-    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)
-      params[:eid] = @old_eid if @remove_eid
-      @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)
-          params[:eid] = @old_eid if @remove_eid
-          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
-      rescue ActiveRecord::RecordInvalid
-      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
-
-    # 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_authorized?
-      authorized_for?(:action => :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/vendor/plugins/active_scaffold/lib/active_scaffold/actions/delete.rb

@@ -1,72 +0,0 @@
-module ActiveScaffold::Actions
-  module Delete
-    def self.included(base)
-      base.before_filter :delete_authorized_filter, :only => [:delete, :destroy]
-    end
-
-    # this method is for html mode. it provides "the missing action" (http://thelucid.com/articles/2006/07/26/simply-restful-the-missing-action).
-    # it also gives us delete confirmation for html mode. woo!
-    def delete
-      destroy_find_record
-      render :action => 'delete'
-    end
-
-    def destroy
-      return redirect_to(params.merge(:action => :delete)) if request.get?
-      do_destroy
-      respond_to_action(:destroy)
-    end
-
-    protected
-    def destroy_respond_to_html
-      flash[:info] = as_(:deleted_model, :model => @record.to_label) if self.successful?
-      return_to_main
-    end
-
-    def destroy_respond_to_js
-      render(:action => 'destroy')
-    end
-
-    def destroy_respond_to_xml
-      render :xml => successful? ? "" : response_object.to_xml, :content_type => Mime::XML, :status => response_status
-    end
-
-    def destroy_respond_to_json
-      render :text => successful? ? "" : response_object.to_json, :content_type => Mime::JSON, :status => response_status
-    end
-
-    def destroy_respond_to_yaml
-      render :text => successful? ? "" : response_object.to_yaml, :content_type => Mime::YAML, :status => response_status
-    end
-
-    def destroy_find_record
-      @record = find_if_allowed(params[:id], :destroy)
-    end
-
-    # A simple method to handle the actual destroying of a record
-    # May be overridden to customize the behavior
-    def do_destroy
-      destroy_find_record
-      begin
-        self.successful = @record.destroy
-      rescue
-        flash[:warning] = as_(:cant_destroy_record, :record => @record.to_label)
-        self.successful = false
-      end
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def delete_authorized?
-      authorized_for?(:action => :destroy)
-    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/vendor/plugins/active_scaffold/lib/active_scaffold/actions/field_search.rb

@@ -1,58 +0,0 @@
-module ActiveScaffold::Actions
-  module FieldSearch
-    def self.included(base)
-      base.before_filter :search_authorized_filter, :only => :show_search
-      base.before_filter :do_search
-    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
-      params[:search] ||= {}
-      @record = active_scaffold_config.model.new
-      respond_to_action(:field_search)
-    end
-
-    protected
-    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 params[:search].nil?
-        like_pattern = active_scaffold_config.field_search.full_text_search? ? '%?%' : '?%'
-        search_conditions = []
-        columns = active_scaffold_config.field_search.columns
-        columns.each do |column|
-          search_conditions << self.class.condition_for_column(column, params[:search][column.name], like_pattern)
-        end
-        search_conditions.compact!
-        self.active_scaffold_conditions = merge_conditions(self.active_scaffold_conditions, *search_conditions)
-        @filtered = !search_conditions.blank?
-
-        includes_for_search_columns = columns.collect{ |column| column.includes}.flatten.uniq.compact
-        self.active_scaffold_joins.concat includes_for_search_columns
-
-        active_scaffold_config.list.user.page = nil
-      end
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def search_authorized?
-      authorized_for?(:action => :read)
-    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

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

@@ -1,95 +0,0 @@
-module ActiveScaffold::Actions
-  module List
-    def self.included(base)
-      base.before_filter :list_authorized_filter, :only => [:index, :table, :update_table, :row, :list]
-    end
-
-    def index
-      list
-    end
-
-    def table
-      do_list
-      render(:action => 'list', :layout => false)
-    end
-
-    # This is called when changing pages, sorts and search
-    def update_table
-      do_list
-      respond_to_action(:update_table)
-    end
-
-    # get just a single row
-    def row
-      render :partial => 'list_record', :locals => {:record => find_if_allowed(params[:id], :read)}
-    end
-
-    def list
-      do_list
-      do_new if active_scaffold_config.list.always_show_create
-      @record ||= active_scaffold_config.model.new if active_scaffold_config.list.always_show_search
-      respond_to_action(:list)
-    end
-    
-    protected
-    def list_respond_to_html
-      render :action => 'list'
-    end
-    def list_respond_to_js
-      render :action => 'list', :layout => false
-    end
-    def list_respond_to_xml
-      render :xml => response_object.to_xml, :content_type => Mime::XML, :status => response_status
-    end
-    def list_respond_to_json
-      render :text => response_object.to_json, :content_type => Mime::JSON, :status => response_status
-    end
-    def list_respond_to_yaml
-      render :text => response_object.to_yaml, :content_type => Mime::YAML, :status => response_status
-    end
-    def update_table_respond_to_html
-      return_to_main
-    end
-    def update_table_respond_to_js
-      render(:partial => 'list')
-    end
-    # The actual algorithm to prepare for the list view
-    def do_list
-      includes_for_list_columns = active_scaffold_config.list.columns.collect{ |c| c.includes }.flatten.uniq.compact
-      self.active_scaffold_joins.concat 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
-        })
-      end
-
-      page = find_page(options);
-      if page.items.blank?
-        page = page.pager.first
-        active_scaffold_config.list.user.page = 1
-      end
-      @page, @records = page, page.items
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def list_authorized?
-      authorized_for?(:action => :read)
-    end
-    private
-    def list_authorized_filter
-      raise ActiveScaffold::ActionNotAllowed unless list_authorized?
-    end
-    def update_table_formats
-      (default_formats + active_scaffold_config.formats).uniq
-    end
-    def list_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.list.formats).uniq
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-module ActiveScaffold::Actions
-  module LiveSearch
-    def self.included(base)
-      base.before_filter :search_authorized_filter, :only => :show_search
-      base.before_filter :do_search
-    end
-
-    def show_search
-      respond_to_action(:live_search)
-    end
-
-    protected
-
-    def live_search_respond_to_html
-      if successful?
-        render(:partial => "live_search", :layout => true)
-      else
-        return_to_main
-      end
-    end
-    
-    def live_search_respond_to_js
-      render(:partial => "live_search")
-    end
-
-    def do_search
-      @query = params[:search].to_s.strip rescue ''
-
-      unless @query.empty?
-        columns = active_scaffold_config.live_search.columns
-        like_pattern = active_scaffold_config.live_search.full_text_search? ? '%?%' : '?%'
-        search_conditions = self.class.create_conditions_for_columns(@query.split(' '), columns, like_pattern)
-        self.active_scaffold_conditions = merge_conditions(self.active_scaffold_conditions, search_conditions)
-        @filtered = !search_conditions.blank?
-
-        includes_for_search_columns = columns.collect{ |column| column.includes}.flatten.uniq.compact
-        self.active_scaffold_joins.concat includes_for_search_columns
-
-        active_scaffold_config.list.user.page = nil
-      end
-    end
-
-    # The default security delegates to ActiveRecordPermissions.
-    # You may override the method to customize.
-    def search_authorized?
-      authorized_for?(:action => :read)
-    end
-    private
-    def search_authorized_filter
-      link = active_scaffold_config.live_search.link || active_scaffold_config.live_search.class.link
-      raise ActiveScaffold::ActionNotAllowed unless self.send(link.security_method)
-    end
-    def live_search_formats
-      (default_formats + active_scaffold_config.formats + active_scaffold_config.live_search.formats).uniq
-    end
-  end
-end