admin_assistant 0.0.1 → 1.0.0

data/lib/admin_assistant/file_column_column.rb

@@ -0,0 +1,73 @@
+class AdminAssistant
+  class FileColumnColumn < Column
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name.to_s
+    end
+    
+    def contains?(column_name)
+      column_name.to_s == @name
+    end
+
+    class View < AdminAssistant::Column::View
+      def file_exists?(record)
+        if @file_exists_method
+          @file_exists_method.call record
+        else
+          !source_for_image_tag(record).nil?
+        end
+      end
+      
+      def image_html(record)
+        @action_view.image_tag(
+          source_for_image_tag(record), :size => @image_size
+        )
+      end
+      
+      def source_for_image_tag(record)
+        if @file_url_method
+          @file_url_method.call record
+        else
+          @action_view.instance_variable_set :@record, record
+          @action_view.url_for_file_column 'record', @column.name
+        end
+      end
+    end
+    
+    class FormView < View
+      include AdminAssistant::Column::FormViewMethods
+      
+      def default_html(form)
+        if file_exists?(form.object)
+          check_box_tag = @action_view.check_box_tag(
+            "#{form.object.class.name.underscore}[#{name}(destroy)]"
+          )
+          <<-HTML
+          <p>Current image:<br />#{image_html(form.object)}</p>
+          <p>Remove: #{check_box_tag}</p>
+          <p>Update: #{form.file_field(name)}</p>
+          HTML
+        else
+          "<p>Add: #{form.file_field(name)}</p>"
+        end
+      end
+    end
+
+    class IndexView < View
+      include AdminAssistant::Column::IndexViewMethods
+      
+      def unconfigured_html(record)
+        image_html(record) if file_exists?(record)
+      end
+    end
+    
+    class ShowView < View
+      include AdminAssistant::Column::ShowViewMethods
+      
+      def html(record)
+        image_html(record) if file_exists?(record)
+      end
+    end
+  end
+end

data/lib/admin_assistant/form_view.rb

@@ -13,52 +13,17 @@ class AdminAssistant
       end
     end
     
-    def after_column_html(column)
-      if after = render_from_custom_template("_after_#{column.name}_input")
-        after
-      else
-        helper_method = "after_#{column.name}_input"
-        if @action_view.respond_to?(helper_method)
-          @action_view.send(helper_method, @record)
-        end
-      end
-    end
-    
-    def column_html(column, rails_form)
-      hff = render_from_custom_template "_#{column.name}_input"
-      hff ||= column_html_from_helper_method(column)
-      hff ||= if settings.read_only.include?(column.name)
-        column.form_value(@record)
-      elsif column.respond_to?(:add_to_form)
-        column.add_to_form(rails_form)
-      else
-        virtual_column_html column
-      end
-      if ah = after_column_html(column)
-        hff << ah
-      end
-      hff
-    end
-    
-    def column_html_from_helper_method(column)
-      html_method = "#{column.name}_html_for_form"
-      if @action_view.respond_to?(html_method)
-        @action_view.send(html_method, @record)
-      end
-    end
-    
     def column_names
-      settings.column_names ||
-          model_class.columns.reject { |ar_column|
-            %w(id created_at updated_at).include?(ar_column.name)
-          }.map { |ar_column|
-            @admin_assistant.column_name_or_assoc_name(ar_column.name)
-          }
+      if %w(new create).include?(@action_view.action_name)
+        settings.columns_for_new
+      elsif %w(edit update).include?(@action_view.action_name)
+        settings.columns_for_edit
+      end
     end
     
     def columns
-      @admin_assistant.columns(column_names).map { |c|
-        c.view(@action_view, :input => settings.inputs[c.name.to_sym])
+      @admin_assistant.accumulate_columns(column_names).map { |c|
+        c.form_view @action_view, @admin_assistant
       }
     end
     
@@ -83,18 +48,6 @@ class AdminAssistant
       @admin_assistant.model_class
     end
     
-    def render_from_custom_template(slug)
-      template = File.join(
-        RAILS_ROOT, 'app/views', controller.controller_path, "#{slug}.html.erb"
-      )
-      if File.exist?(template)
-        @action_view.render(
-          :file => template,
-          :locals => {model_class.name.underscore.to_sym => @record}
-        )
-      end
-    end
-    
     def settings
       @admin_assistant.form_settings
     end
@@ -106,19 +59,5 @@ class AdminAssistant
     def title
       (@record.id ? "Edit" : "New") + " #{@admin_assistant.model_class_name}"
     end
-    
-    def virtual_column_html(column)
-      input_name = "#{model_class.name.underscore}[#{column.name}]"
-      input_type = settings.inputs[column.name.to_sym]
-      fv = column.form_value @record
-      if input_type
-        if input_type == :check_box
-          @action_view.send(:check_box_tag, input_name, '1', fv) +
-              @action_view.send(:hidden_field_tag, input_name, '0')
-        end
-      else
-        @action_view.send(:text_field_tag, input_name, fv)
-      end
-    end
   end
 end

data/lib/admin_assistant/helper.rb

@@ -1,7 +1,9 @@
 class AdminAssistant
   module Helper
-    def admin_assistant_includes
-      stylesheet_link_tag 'admin_assistant'
+    def admin_assistant_includes(opts = {})
+      theme = opts[:theme] || 'default'
+      stylesheet_link_tag("admin_assistant/#{theme}") +
+          javascript_include_tag('admin_assistant')
     end
   end
 end

data/lib/admin_assistant/index.rb

@@ -2,32 +2,37 @@ require 'ar_query'
 
 class AdminAssistant
   class Index
-    def initialize(admin_assistant, url_params = {})
-      @admin_assistant = admin_assistant
-      @url_params = url_params
+    attr_reader :controller_methods
+    
+    def initialize(admin_assistant, url_params = {}, controller_methods = {})
+      @admin_assistant, @url_params, @controller_methods =
+            admin_assistant, url_params, controller_methods
     end
     
     def belongs_to_sort_column
-      columns.detect { |column|
-        column.is_a?(BelongsToColumn) && column.name.to_s == @url_params[:sort]
+      @admin_assistant.accumulate_belongs_to_columns(column_names).detect { |c|
+        c.name.to_s == sort
       }
     end
     
+    def column_names
+      settings.column_names || model_class.columns.map(&:name)
+    end
+    
     def columns
-      column_names = settings.column_names || model_class.columns.map { |c|
-        @admin_assistant.column_name_or_assoc_name(c.name)
-      }
-      @admin_assistant.columns column_names
+      @admin_assistant.accumulate_columns column_names
     end
     
-    def conditions
+    def conditions_from_settings
       settings.conditions
     end
     
     def find_include
+      fi = settings.include || []
       if by_assoc = belongs_to_sort_column
-        by_assoc.name
+        fi << by_assoc.name
       end
+      fi
     end
     
     def model_class
@@ -53,25 +58,34 @@ class AdminAssistant
           :order => order_sql, :include => find_include,
           :per_page => 25, :page => @url_params[:page]
         )
-        search.add_to_query(ar_query)
-        if conditions
-          conditions_sql = conditions.call @url_params
+        if @controller_methods[:conditions_for_index]
+          sql = @controller_methods[:conditions_for_index].call
+          ar_query.condition_sqls << sql if sql
+        elsif conditions_from_settings
+          if conditions_from_settings.respond_to?(:call)
+            conditions_sql = conditions_from_settings.call @url_params
+          else
+            conditions_sql = conditions_from_settings
+          end
           ar_query.condition_sqls << conditions_sql if conditions_sql
         end
+        search.add_to_query(ar_query)
         if settings.total_entries
-          ar_query[:total_entries] = settings.total_entries.call
+          ar_query.total_entries = settings.total_entries.call
         end
-        @records = model_class.paginate :all, ar_query
+        @records = model_class.paginate :all, ar_query.to_hash
       end
       @records
     end
     
     def search
-      @search ||= Search.new(@admin_assistant, @url_params['search'])
+      @search ||= AdminAssistant::Search.new(
+        @admin_assistant, @url_params['search']
+      )
     end
     
-    def search_terms
-      @url_params['search']
+    def search_requested?
+      !@url_params['search'].blank?
     end
     
     def settings
@@ -79,14 +93,17 @@ class AdminAssistant
     end
     
     def sort
-      @url_params[:sort]
+      @url_params[:sort] ||
+          (settings.sort_by.to_s if settings.sort_by.is_a?(Symbol))
     end
     
     def sort_column
-      if @url_params[:sort]
+      if sort
         columns.detect { |c|
-          c.name.to_s == @url_params[:sort]
+          c.name.to_s == sort
         } || belongs_to_sort_column
+      elsif settings.sort_by.is_a?(Symbol)
+        columns.detect { |c| c.name == settings.sort_by.to_s }
       end
     end
     
@@ -95,86 +112,89 @@ class AdminAssistant
     end
     
     def view(action_view)
-      View.new self, action_view
+      @view ||= View.new(self, action_view, @admin_assistant)
     end
     
-    class Search
-      def initialize(admin_assistant, search_params)
-        @admin_assistant, @search_params = admin_assistant, search_params
-        @search_params ||= {}
+    class View
+      def initialize(index, action_view, admin_assistant)
+        @index, @action_view, @admin_assistant =
+            index, action_view, admin_assistant
       end
       
-      def [](name)
-        @search_params[name]
-      end
-    
-      def add_to_query(ar_query)
-        columns.each do |column|
-          column.add_to_query ar_query
-        end
+      def ajax_toggle_allowed?
+        @admin_assistant.update?
       end
       
       def columns
-        search_field_names = settings.search_fields
-        if search_field_names.empty?
-          [DefaultSearchColumn.new(
-            default_terms, @admin_assistant.model_class
-          )]
-        else
-          columns = search_field_names.map { |column_name|
-            @admin_assistant.column column_name.to_s
+        unless @columns
+          @columns = @index.columns.map { |c|
+            c.index_view @action_view, @admin_assistant, :index => @index
           }
-          columns.each do |c|
-            c.search_terms = @search_params[c.name]
-          end
-          columns
         end
+        @columns
       end
       
-      def column_views(action_view)
-        columns.map { |c|
-          opts = {:search => self}
-          if c.respond_to?(:name)
-            opts[:boolean_labels] = settings.boolean_labels[c.name]
-          end
-          c.view(action_view, opts)
-        }
-      end
-      
-      def default_terms
-        @search_params if @search_params.is_a?(String)
+      def destroy?
+        @destroy ||= @admin_assistant.destroy?
       end
       
-      def id
+      def edit?
+        @edit ||= @admin_assistant.edit?
       end
       
-      def method_missing(meth, *args)
-        if column = columns.detect { |c| c.name == meth.to_s }
-          column.search_value
+      def header
+        if block = @index.settings.header
+          block.call @action_view.params
         else
-          super
+          @admin_assistant.model_class_name.pluralize.capitalize
         end
       end
-    
-      def settings
-        @admin_assistant.index_settings
+
+      def right_column?
+        edit? or destroy? or show? or !right_column_lambdas.empty?
       end
-    end
-    
-    class View
-      def initialize(index, action_view)
-        @index, @action_view = index, action_view
+      
+      def right_column_lambdas
+        @right_column_lambdas ||=
+            @admin_assistant.index_settings.right_column_links
       end
       
-      def columns
-        @index.columns.map { |c|
-          c.view(
-            @action_view,
-            :boolean_labels => @index.settings.boolean_labels[c.name],
-            :sort_order => (@index.sort_order if c.name == @index.sort),
-            :link_to_args => @index.settings.link_to_args[c.name.to_sym]
-          )
-        }
+      def right_column_links(record)
+        links = ""
+        if edit?
+          links << @action_view.link_to(
+            'Edit', :action => 'edit', :id => record.id
+          ) << " "
+        end
+        if destroy?
+          links << @action_view.link_to_remote(
+            'Delete',
+            :url => {:action => 'destroy', :id => record.id},
+            :confirm => 'Are you sure?',
+            :success =>
+                "Effect.Fade('#{@admin_assistant.model_class.name.underscore}_#{record.id}')",
+            :method => :delete
+          ) << ' '
+        end
+        if show?
+          links << @action_view.link_to(
+            'Show', :action => 'show', :id => record.id
+          ) << ' '
+        end
+        right_column_lambdas.each do |lambda|
+          link_args = lambda.call record
+          links << @action_view.link_to(*link_args)
+        end
+        if @action_view.respond_to?(:extra_right_column_links_for_index)
+          links << @action_view.extra_right_column_links_for_index(
+            record
+          ) || ''
+        end
+        links
+      end
+      
+      def show?
+        @show ||= @admin_assistant.show?
       end
     end
   end

data/lib/admin_assistant/paperclip_column.rb

@@ -0,0 +1,45 @@
+class AdminAssistant
+  class PaperclipColumn < Column
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name.to_s
+    end
+    
+    def contains?(column_name)
+      column_name.to_s == @name ||
+      column_name.to_s =~
+          /^#{@name}_(file_name|content_type|file_size|updated_at)$/
+    end
+    
+    class View < AdminAssistant::Column::View
+      def image_html(record)
+        @action_view.image_tag record.send(@column.name).url
+      end
+    end
+    
+    class FormView < View
+      include AdminAssistant::Column::FormViewMethods
+      
+      def default_html(form)
+        form.file_field name
+      end
+    end
+
+    class IndexView < View
+      include AdminAssistant::Column::IndexViewMethods
+      
+      def html(record)
+        image_html record
+      end
+    end
+    
+    class ShowView < View
+      include AdminAssistant::Column::ShowViewMethods
+      
+      def html(record)
+        image_html record
+      end
+    end
+  end
+end

data/lib/admin_assistant/polymorphic_belongs_to_column.rb

@@ -0,0 +1,102 @@
+class AdminAssistant
+  class PolymorphicBelongsToColumn < Column
+    def initialize(belongs_to_assoc)
+      @belongs_to_assoc = belongs_to_assoc
+    end
+    
+    def add_to_query_condition(ar_query_condition, search)
+      kv = (key_value = search.send(association_foreign_key)) && 
+           !key_value.blank?
+      tv = (type_value = search.send(foreign_type_field)) &&
+           !type_value.blank?
+      if kv and tv
+        ar_query_condition.add_condition do |subcond|
+          subcond.boolean_join = :and
+          subcond.sqls << "#{association_foreign_key} = ?"
+          subcond.bind_vars << key_value
+          subcond.sqls << "#{foreign_type_field} = ?"
+          subcond.bind_vars << type_value
+        end
+      end
+    end
+    
+    def association_foreign_key
+      @belongs_to_assoc.association_foreign_key
+    end
+    
+    def attributes_for_search_object(search_params)
+      atts = {}
+      atts[association_foreign_key.to_sym] = 
+          search_params[association_foreign_key]
+      atts[foreign_type_field.to_sym] = search_params[foreign_type_field]
+      if !atts[foreign_type_field.to_sym].blank?
+        atts[name.to_sym] = Module.const_get(
+          search_params[foreign_type_field]
+        ).find_by_id(search_params[association_foreign_key])
+      else
+        atts[name.to_sym] = nil
+      end
+      atts
+    end
+    
+    def contains?(column_name)
+      column_name.to_s == name
+    end
+      
+    def foreign_type_field
+      @belongs_to_assoc.options[:foreign_type]
+    end
+    
+    def match_text_fields_in_search
+      false
+    end
+    
+    def name
+      @belongs_to_assoc.name.to_s
+    end
+    
+    class FormView < AdminAssistant::Column::View
+      include AdminAssistant::Column::FormViewMethods
+      
+      def default_html(form)
+        opts_for_select = @polymorphic_types.map { |t| [t.name, t.name] }
+        form.select(name + '_type', opts_for_select, @select_options) + " " +
+            form.text_field(name + '_id', :class => 'integer')
+      end
+    end
+
+    class IndexView < AdminAssistant::Column::View
+      include AdminAssistant::Column::IndexViewMethods
+      
+      def value(record)
+        v = record.send name
+        if v
+          target = AssociationTarget.new v.class
+          str = target.name.capitalize
+          fv = target.assoc_value v
+          if fv
+            str << " '#{fv}'"
+          else
+            str << " #{v.id}"
+          end
+        end
+      end
+    end
+    
+    class SearchView < AdminAssistant::Column::View
+      include AdminAssistant::Column::SearchViewMethods
+      
+      def html(form)
+        @action_view.send(
+          :render,
+          :file => AdminAssistant.template_file('_polymorphic_field_search'),
+          :use_full_path => false,
+          :locals => {
+            :record => @search, :column => @column,
+            :polymorphic_types => @polymorphic_types
+          }
+        )
+      end
+    end
+  end
+end

data/lib/admin_assistant/request/autocomplete.rb

@@ -0,0 +1,47 @@
+class AdminAssistant
+  module Request
+    class Autocomplete < Base
+      def associated_class
+        @associated_class ||= Module.const_get(
+          underscored_assoc_class_name.camelize
+        )
+      end
+      
+      def call
+        render_template_file(
+          'autocomplete', :layout => false,
+          :locals => {
+            :records => records, :prefix => underscored_assoc_class_name,
+            :associated_class => associated_class
+          }
+        )
+      end
+      
+      def records
+        action =~ /autocomplete_(.*)/
+        associated_class = Module.const_get $1.camelize
+        target = AssociationTarget.new associated_class
+        field = target.default_name_method
+        associated_class.find(
+          :all,
+          :conditions => [
+            "LOWER(#{field}) like ?",
+            "%#{search_string.downcase unless search_string.nil?}%"
+          ],
+          :limit => 10, :order => "length(#{field}), lower(#{field})"
+        )
+      end
+      
+      def search_string
+        @controller.params[
+          "#{underscored_assoc_class_name}_autocomplete_input"
+        ]
+      end
+      
+      def underscored_assoc_class_name
+        action =~ /autocomplete_(.*)/
+        $1
+      end
+    end
+  end
+end