activeadmin 0.1.1 → 0.2.0

data/.gitignore

@@ -1,25 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC
-.bundle
-spec/rails
-*.sqlite3-journal
-Gemfile.lock

data/active_admin.gemspec

@@ -1,22 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
- 
-require 'active_admin/version' 
-
-Gem::Specification.new do |s|
-  s.name        = "active_admin"
-  s.version     = ActiveAdmin::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Greg Bell"]
-  s.email       = ["gregdbell@gmail.com"]
-  s.homepage    = "http://github.com/gregbell/active_admin"
-  s.summary     = "The missing administration framework for Ruby on Rails"
-  s.description = "ActiveAdmin DRY's your administration UI so that you can concentrate on what's actually important" 
-
-  s.add_dependency 'inherited_views', '>= 0.0.1'
-  s.add_dependency 'meta_search'
-  
-  s.files        = Dir.glob("lib/**/*") + %w(LICENSE README.rdoc)
-  s.require_path = 'lib'
-end

data/lib/active_admin/action_builder.rb

@@ -1,60 +0,0 @@
-module ActiveAdmin
-
-  # Member Actions give you the functionality of defining both the
-  # action and the route directly from your ActiveAdmin registration
-  # block.
-  #
-  # For example:
-  #
-  #   ActiveAdmin.register Post do
-  #     member_action :comments do
-  #       @post = Post.find(params[:id]
-  #       @comments = @post.comments
-  #     end
-  #   end
-  #
-  # Will create a new controller action comments and will hook it up to
-  # the named route (comments_admin_post_path) /admin/posts/:id/comments
-  #
-  # You can treat everything within the block as a standard Rails controller
-  # action.
-  # 
-  module ActionBuilder
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      def member_action(name, options = {}, &block)
-        active_admin_config.member_actions << ControllerAction.new(name, options)
-        define_method(name, &block || Proc.new{})
-      end
-
-      def clear_member_actions!
-        active_admin_config.clear_member_actions!
-      end
-
-
-      def collection_action(name, options = {}, &block)
-        active_admin_config.collection_actions << ControllerAction.new(name, options)
-        define_method(name, &block || Proc.new{})
-      end
-
-      def clear_collection_actions!
-        active_admin_config.clear_collection_actions!
-      end
-    end
-
-    class ControllerAction
-      attr_reader :name
-      def initialize(name, options = {})
-        @name, @options = name, options
-      end
-
-      def http_verb
-        @options[:method] ||= :get
-      end
-    end
-  end
-end

data/lib/active_admin/breadcrumbs.rb

@@ -1,26 +0,0 @@
-module ActiveAdmin
-  module Breadcrumbs
-    
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-      
-    protected
-
-    def add_breadcrumb(name, url = '')
-      @breadcrumbs ||= []
-      url = send(url) if url.is_a?(Symbol)
-      @breadcrumbs << [name, url]
-    end
-
-    module ClassMethods
-
-      def add_breadcrumb(name, url, options = {})
-        before_filter options do |controller|
-          controller.send(:add_breadcrumb, name, url)
-        end
-      end
-    
-    end
-  end
-end

data/lib/active_admin/dashboards/renderer.rb

@@ -1,45 +0,0 @@
-module ActiveAdmin
-  module Dashboards
-    class Renderer < ::ActiveAdmin::Pages::Base
-
-      def main_content
-        if @dashboard_sections && @dashboard_sections.any?
-          render_sections(@dashboard_sections)
-        else
-          default_welcome_section
-        end
-      end
-
-      protected
-
-      def title
-        "Dashboard"
-      end
-
-      def render_sections(sections)
-        content_tag :table, :class => "dashboard" do
-          sections.in_groups_of(3, false).collect do |row|
-            content_tag :tr do
-              row.collect do |section| 
-                content_tag :td, render_section(section)
-              end.join
-            end
-          end.join
-        end
-      end
-
-      # Renders each section using their renderer
-      def render_section(section)
-        renderer = section.renderer.new(self)
-        renderer.to_html(section)
-      end
-
-      def default_welcome_section
-        content_tag :p, :id => "dashboard_default_message" do
-          "Welcome to Active Admin. This is the default dashboard page. To add dashboard sections, checkout 'app/admin/dashboards.rb'"
-        end
-      end
-
-    end
-  end
-end

data/lib/active_admin/dashboards/section_renderer.rb

@@ -1,28 +0,0 @@
-module ActiveAdmin
-  module Dashboards
-    class SectionRenderer < ::ActiveAdmin::Renderer
-
-      def to_html(section)
-        @section = section
-        content_tag :div, title_wrapped + content_wrapped, :class => 'dashboard_section', :id => "#{section.name.to_s.downcase.gsub(' ', '_')}_dashboard_section"
-      end
-
-      def title_wrapped
-        content_tag :h3, title
-      end
-
-      def title
-        @section.name.to_s.titleize
-      end
-
-      def content_wrapped
-        content_tag :div, content, :class => 'dashboard_section_content'
-      end
-
-      def content
-        instance_eval(&@section.block)
-      end
-
-    end
-  end
-end

data/lib/active_admin/filters.rb

@@ -1,189 +0,0 @@
-module ActiveAdmin
-  module Filters
-
-    def self.included(base)
-      base.extend ClassMethods
-      base.send :helper_method, :filters_config
-    end
-
-    module ClassMethods
-      def filter(attribute, options = {})
-        return false if attribute.nil?
-        @filters ||= []
-        @filters << options.merge(:attribute => attribute)
-      end
-
-      def filters_config
-        @filters && @filters.any? ? @filters : default_filters_config
-      end
-
-      def reset_filters!
-        @filters = []
-      end
-
-      # Returns a sane set of filters by default for the object
-      def default_filters_config
-        default_association_filters + default_content_filters
-      end
-
-      # Returns a default set of filters for the associations
-      def default_association_filters
-        if resource_class.respond_to?(:reflections)
-          resource_class.reflections.collect{|name, r| { :attribute => name }}
-        else
-          []
-        end
-      end
-
-      # Returns a default set of filters for the content columns
-      def default_content_filters
-        if resource_class.respond_to?(:content_columns)
-          resource_class.content_columns.collect{|c| { :attribute => c.name.to_sym } }
-        else
-          []
-        end
-      end
-    end
-
-
-    def filters_config
-      self.class.filters_config
-    end
-
-
-    class FormBuilder < FormBuilder
-    
-      def filter(method, options = {})
-        return "" if method.nil? || method == ""
-        options[:as] ||= default_filter_type(method)
-        return "" unless options[:as]
-        content = skip_form_buffers do
-          send("filter_#{options.delete(:as)}_input", method, options)
-        end
-        @form_buffers.last << template.content_tag(:div, content, :class => "filter-form-field")
-      end
-
-      protected
-
-      def filter_string_input(method, options = {})
-        field_name = "#{method}_contains"
-
-        [ label(field_name, "Search #{method.to_s.titlecase}"),
-          text_field(field_name)
-        ].join("\n").html_safe
-      end
-
-      def filter_date_range_input(method, options = {})
-        gt_field_name = "#{method}_gte"
-        lt_field_name = "#{method}_lte"
-
-        [ label(gt_field_name, method.to_s.titlecase),
-          filter_date_text_field(gt_field_name),
-          " - ",
-          filter_date_text_field(lt_field_name)
-        ].join("\n").html_safe
-      end
-
-      def filter_date_text_field(method)
-        current_value = @object.send(method)
-        text_field(method, :size => 12, :class => "datepicker", :max => 10, :value => current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "")
-      end
-
-      def filter_numeric_input(method, options = {})
-        filters = numeric_filters_for_method(method, options.delete(:filters) || default_numeric_filters)
-        current_filter = current_numeric_scope(filters)
-        filter_select = @template.select_tag '', @template.options_for_select(filters, current_filter), 
-                                    :onchange => "document.getElementById('#{method}_numeric').name = 'q[' + this.value + ']';"
-        filter_input = text_field current_filter, :size => 10, :id => "#{method}_numeric"
-
-        [ label(method),
-          filter_select,
-          " ",
-          filter_input
-        ].join("\n").html_safe
-      end
-      
-      def numeric_filters_for_method(method, filters)
-        filters.collect{|scope| [scope[0], [method,scope[1]].join("_") ] }
-      end
-
-      # Returns the scope for which we are currently searching. If no search is available
-      # it returns the first scope
-      def current_numeric_scope(filters)
-        filters[1..-1].inject(filters.first){|a,b| object.send(b[1].to_sym) ? b : a }[1]
-      end
-
-      def default_numeric_filters
-        [['Equal To', 'eq'], ['Greater Than', 'gt'], ['Less Than', 'lt']]
-      end
-
-      def filter_select_input(method, options = {})
-        association_name = method.to_s.gsub(/_id$/, '').to_sym
-        input_name = (generate_association_input_name(method).to_s + "_eq").to_sym
-        collection = find_collection_for_column(association_name, options)
-
-        [ label(input_name, method.to_s.titlecase),
-          select(input_name, collection, options.merge(:include_blank => 'Any'))
-        ].join("\n").html_safe
-      end
-
-      def filter_check_boxes_input(method, options = {})
-        input_name = (generate_association_input_name(method).to_s + "_in").to_sym
-        collection = find_collection_for_column(method, options)
-        selected_values = @object.send(input_name) || []
-        checkboxes = collection.map do |c|
-          label = c.is_a?(Array) ? c.first : c
-          value = c.is_a?(Array) ? c.last : c
-          "<label><input type=\"checkbox\" name=\"q[#{input_name}][]\" value=\"#{value}\" #{selected_values.include?(value) ? "checked" : ""}/> #{label}</label>"
-        end.join("\n").html_safe
-
-        [ label(input_name, method.to_s.titlecase),
-          checkboxes
-        ].join("\n").html_safe
-      end
-
-      # Override the standard finder to accept a proc
-      def find_collection_for_column(method, options = {})
-        options = options.dup
-        case options[:collection]
-        when Proc
-          options[:collection] = options[:collection].call
-        end
-        super(method, options)
-      end
-
-      # Returns the default filter type for a given attribute
-      def default_filter_type(method)
-        if column = column_for(method)
-          case column.type
-          when :date, :datetime
-            return :date_range
-          when :string, :text
-            return :string
-          when :integer
-            return :select if method.to_s =~ /_id$/
-            return :numeric
-          when :float, :decimal
-            return :numeric
-          end
-        end
-
-        if reflection = reflection_for(method)
-          return :select if reflection.macro == :belongs_to
-        end
-      end
-
-      # Returns the column for an attribute on the object being searched
-      # if it exists. Otherwise returns nil
-      def column_for(method)
-        @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
-      end
-
-      # Returns the association reflection for the method if it exists
-      def reflection_for(method)
-        @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
-      end
-
-    end    
-  end
-end

data/lib/active_admin/pages.rb

@@ -1,11 +0,0 @@
-module ActiveAdmin
-  module Pages
-
-    autoload :Base,       'active_admin/pages/base'
-    autoload :Index,      'active_admin/pages/index'
-    autoload :New,        'active_admin/pages/new'
-    autoload :Show,       'active_admin/pages/show'
-    autoload :Edit,       'active_admin/pages/edit'
-
-  end
-end

data/lib/active_admin/pages/base.rb

@@ -1,92 +0,0 @@
-module ActiveAdmin
-  module Pages
-    class Base < ::ActiveAdmin::Renderer
-
-      def breadcrumb(separator = "/")
-        content_tag :span, :class => "breadcrumb" do
-          @breadcrumbs.map { |txt, path| link_to_unless((path.blank? || current_page?(path)), h(txt), path) }.join(" #{content_tag(:span, separator, :class => "breadcrumb_sep")} ")
-        end
-      end
-
-      def main_content
-        "Please implement #{self.class.name}#main_content to display content.".html_safe
-      end
-
-      def title_bar
-        content_for :title_bar do
-          [breadcrumb, title_tag, action_items].join.html_safe
-        end
-      end
-
-      def title_tag
-        content_tag :h2, title, :id => 'page_title'
-      end
-
-      def title
-        self.class.name
-      end
-
-      # Set's the page title for the layout to render
-      def set_page_title
-        set_ivar_on_view "@page_title", title
-      end
-
-      def action_items_renderer
-        ActiveAdmin::ActionItems::Renderer
-      end
-
-      def action_items
-        items = controller.class.action_items_for(params[:action])
-        action_items_renderer.new(self).to_html(items)
-      end
-
-      # Returns the renderer class to use to render the sidebar
-      #
-      # You could override this method and return your own custom
-      # sidebar renderer
-      def sidebar_renderer
-        ActiveAdmin::Sidebar::Renderer
-      end
-
-      # Returns the sidebar sections to render for the current action
-      def sidebar_sections
-        controller.class.sidebar_sections_for(params[:action])
-      end
-
-      # Renders the sidebar
-      def sidebar
-        content_for :sidebar do
-          sidebar_renderer.new(self).to_html(sidebar_sections)
-        end
-      end
-
-      # Renders the content for the footer
-      def footer
-        content_for :footer do
-          content_tag :p, "Powered by #{link_to("Active Admin", "http://www.activeadmin.info")} #{ActiveAdmin::VERSION}".html_safe
-        end
-      end
-
-      def flash_messages
-        content_for :flash_messages do
-          if flash.keys.any?
-            content_tag :div, :class => 'flashes' do
-              flash.collect do |type, message|
-                content_tag :div, message, :class => "flash flash_#{type}"
-              end.join
-            end
-          end
-        end
-      end
-
-      def to_html
-        set_page_title
-        title_bar
-        flash_messages
-        footer
-        sidebar
-        main_content
-      end
-    end
-  end
-end