nsm-activeadmin 0.2.2

data/lib/active_admin/dsl.rb

@@ -0,0 +1,224 @@
+module ActiveAdmin
+
+  #
+  # The Active Admin DSL. This class is where all the registration blocks
+  # are instance eval'd. This is the central place for the API given to 
+  # users of Active Admin
+  #
+  class DSL
+
+    # Runs the registration block inside this object
+    def run_registration_block(config, &block)
+      @config = config
+      instance_eval &block
+    end
+
+    private
+
+    # The instance of ActiveAdmin::Resource that's being registered
+    # currently. You can use this within your registration blocks to
+    # modify options:
+    #
+    # eg:
+    #   
+    #   ActiveAdmin.register Post do
+    #     config.admin_notes = false
+    #   end
+    #
+    def config
+      @config
+    end
+
+    # Returns the controller for this resource. If you pass a
+    # block, it will be eval'd in the controller
+    #
+    # Example:
+    #   
+    #   ActiveAdmin.register Post do
+    #
+    #     controller do
+    #       def some_method_on_controller
+    #         # Method gets added to Admin::PostsController
+    #       end
+    #     end
+    #
+    #   end
+    #
+    def controller(&block)
+      @config.controller.class_eval(&block) if block_given?
+      @config.controller
+    end
+
+    def belongs_to(target, options = {})
+      config.belongs_to(target, options)
+    end
+
+    def menu(options = {})
+      config.menu(options)
+    end
+
+    # Scope this controller to some object which has a relation
+    # to the resource. Can either accept a block or a symbol 
+    # of a method to call.
+    #
+    # Eg:
+    #
+    #   ActiveAdmin.register Post do
+    #     scope_to :current_user
+    #   end
+    #
+    # Then every time we instantiate and object, it would call
+    #   
+    #   current_user.posts.build
+    #
+    # By default Active Admin will use the resource name to build a
+    # method to call as the association. If its different, you can 
+    # pass in the association_method as an option.
+    #
+    #   scope_to :current_user, :association_method => :blog_posts
+    #
+    # will result in the following
+    # 
+    #   current_user.blog_posts.build
+    #
+    def scope_to(*args, &block)
+      options = args.extract_options!
+      method = args.first
+
+      config.scope_to = block_given? ? block : method
+      config.scope_to_association_method = options[:association_method]
+    end
+
+    # Create a scope
+    def scope(*args, &block)
+      config.scope(*args, &block)
+    end
+
+    # Add a new action item to the resource
+    #
+    # @param [Hash] options valid keys include:
+    #                 :only:  A single or array of controller actions to display
+    #                         this action item on.
+    #                 :except: A single or array of controller actions not to
+    #                          display this action item on.
+    def action_item(options = {}, &block)
+      config.add_action_item(options, &block)
+    end
+
+    # Configure the index page for the resource
+    def index(options = {}, &block)
+      options[:as] ||= :table
+      controller.set_page_config :index, options, &block
+    end
+
+    # Configure the show page for the resource
+    def show(options = {}, &block)
+      # TODO: controller.set_page_config just sets page_configs on the Resource (config) obj
+      controller.set_page_config :show, options, &block
+    end
+
+    def form(options = {}, &block)
+      options[:block] = block
+      controller.form_config = options
+    end
+
+    def sidebar(name, options = {}, &block)
+      config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
+    end
+
+    # Configure the CSV format
+    #
+    # For example:
+    #
+    #   csv do
+    #     column :name
+    #     column("Author") { |post| post.author.full_name }
+    #   end
+    #
+    def csv(&block)
+      config.csv_builder = CSVBuilder.new(&block)
+    end
+
+    # 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.
+    # 
+    def member_action(name, options = {}, &block)
+      config.member_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    def collection_action(name, options = {}, &block)
+      config.collection_actions << ControllerAction.new(name, options)
+      controller do
+        define_method(name, &block || Proc.new{})
+      end
+    end
+
+    # Defined Callbacks
+    #
+    # == After Build
+    # Called after the resource is built in the new and create actions.
+    #
+    # ActiveAdmin.register Post do
+    #   after_build do |post|
+    #     post.author = current_user
+    #   end
+    # end
+    #
+    # == Before / After Create
+    # Called before and after a resource is saved to the db on the create action.
+    #
+    # == Before / After Update
+    # Called before and after a resource is saved to the db on the update action.
+    #
+    # == Before / After Save
+    # Called before and after the object is saved in the create and update action.
+    # Note: Gets called after the create and update callbacks
+    #
+    # == Before / After Destroy
+    # Called before and after the object is destroyed from the database.
+    #
+    delegate :before_build,   :after_build,   :to => :controller
+    delegate :before_create,  :after_create,  :to => :controller
+    delegate :before_update,  :after_update,  :to => :controller
+    delegate :before_save,    :after_save,    :to => :controller
+    delegate :before_destroy, :after_destroy, :to => :controller
+
+    # Filters
+    delegate :filter, :to => :controller
+
+
+    # Standard rails filters
+    delegate :before_filter, :skip_before_filter, :after_filter, :around_filter, :to => :controller
+
+    # Specify which actions to create in the controller
+    #
+    # Eg:
+    #   
+    #   ActiveAdmin.register Post do
+    #     actions :index, :show
+    #   end
+    #
+    # Will only create the index and show actions (no create, update or delete)
+    delegate :actions, :to => :controller
+
+  end
+end

data/lib/active_admin/engine.rb

@@ -0,0 +1,4 @@
+module ActiveAdmin
+  class Engine < Rails::Engine
+  end
+end

data/lib/active_admin/event.rb

@@ -0,0 +1,31 @@
+module ActiveAdmin
+
+  class EventDispatcher
+    def initialize
+      @events = {}
+    end
+
+    def clear_all_subscribers!
+      @events = {}
+    end
+
+    def subscribe(event, &block)
+      @events[event] ||= []
+      @events[event] << block
+    end
+
+    def subscribers(event)
+      @events[event] || []
+    end
+
+    def dispatch(event, *args)
+      subscribers(event).each do |subscriber|
+        subscriber.call(*args)
+      end
+    end
+  end
+
+  # ActiveAdmin::Event is set to a dispatcher
+  Event = EventDispatcher.new
+
+end

data/lib/active_admin/form_builder.rb

@@ -0,0 +1,109 @@
+require 'formtastic'
+
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::SemanticFormBuilder
+
+    attr_reader :form_buffers
+
+    def initialize(*args)
+      @form_buffers = ["".html_safe]
+      super
+    end
+
+    def inputs(*args, &block)
+      # Store that we are creating inputs without a block
+      @inputs_with_block = block_given? ? true : false
+      content = with_new_form_buffer { super }
+      form_buffers.last << content.html_safe
+    end
+
+    # The input method returns a properly formatted string for
+    # its contents, so we want to skip the internal buffering
+    # while building up its contents
+    def input(*args)
+      content = with_new_form_buffer { super }
+      return content.html_safe unless @inputs_with_block
+      form_buffers.last << content.html_safe
+    end
+
+    # The buttons method always needs to be wrapped in a new buffer
+    def buttons(*args, &block)
+      content = with_new_form_buffer do
+        block_given? ? super : super { commit_button_with_cancel_link }
+      end
+      form_buffers.last << content.html_safe
+    end
+
+    def commit_button(*args)
+      content = with_new_form_buffer{ super }
+      form_buffers.last << content.html_safe
+    end
+
+    def cancel_link(url = nil, html_options = {}, li_attributes = {})
+      li_attributes[:class] ||= "cancel"
+      url ||= {:action => "index"}
+      template.content_tag(:li, (template.link_to I18n.t('active_admin.cancel'), url, html_options), li_attributes)
+    end
+
+    def commit_button_with_cancel_link
+      content = commit_button
+      content << cancel_link
+    end
+
+    def datepicker_input(method, options)
+      options = options.dup
+      options[:input_html] ||= {}
+      options[:input_html][:class] = [options[:input_html][:class], "datepicker"].compact.join(' ')
+      options[:input_html][:size] ||= "10"
+      string_input(method, options)
+    end
+
+    def has_many(association, options = {}, &block)
+      options = { :for => association }.merge(options)
+      options[:class] ||= ""
+      options[:class] << "inputs has_many_fields"
+
+      # Add Delete Links
+      form_block = proc do |has_many_form|
+        block.call(has_many_form) + if has_many_form.object.new_record?
+                                      template.content_tag :li do
+                                        template.link_to I18n.t('active_admin.has_many_delete'), "#", :onclick => "$(this).closest('.has_many_fields').remove(); return false;", :class => "button"
+                                      end
+                                    else
+                                    end
+      end
+
+      content = with_new_form_buffer do
+        template.content_tag :div, :class => "has_many #{association}" do
+          form_buffers.last << template.content_tag(:h3, association.to_s.titlecase)
+          inputs options, &form_block
+
+          # Capture the ADD JS
+          js = with_new_form_buffer do
+            inputs_for_nested_attributes  :for => [association, object.class.reflect_on_association(association).klass.new],
+                                          :class => "inputs has_many_fields",
+                                          :for_options => {
+                                            :child_index => "NEW_RECORD"
+                                          }, &form_block
+          end
+
+          js = template.escape_javascript(js)
+          js = template.link_to I18n.t('active_admin.has_many_new', :model => association.to_s.singularize.titlecase), "#", :onclick => "$(this).before('#{js}'.replace(/NEW_RECORD/g, new Date().getTime())); return false;", :class => "button"
+
+          form_buffers.last << js.html_safe
+        end
+      end
+      form_buffers.last << content.html_safe
+    end
+
+    private
+
+    def with_new_form_buffer
+      form_buffers << "".html_safe
+      return_value = yield
+      form_buffers.pop
+      return_value
+    end
+
+  end
+end

data/lib/active_admin/helpers/optional_display.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  
+  # Shareable module to give a #display_on?(action) method
+  # which returns true or false depending on an options hash.
+  #
+  # The options hash accepts:
+  #
+  # :only => :index
+  # :only => [:index, :show]
+  # :except => :index
+  # :except => [:index, :show]
+  #
+  # call #normalize_display_options! after @options has been set
+  # to ensure that the display options are setup correctly
+
+  module OptionalDisplay
+    def display_on?(action)
+      return @options[:only].include?(action.to_sym) if @options[:only]
+      return !@options[:except].include?(action.to_sym) if @options[:except]
+      true
+    end
+
+    private
+
+    def normalize_display_options!
+      if @options[:only]
+        @options[:only] = @options[:only].is_a?(Array) ? @options[:only] : [@options[:only]]
+      end
+      if @options[:except]
+        @options[:except] = @options[:except].is_a?(Array) ? @options[:except] : [@options[:except]]
+      end
+    end
+  end
+end

data/lib/active_admin/helpers/settings.rb

@@ -0,0 +1,63 @@
+require 'active_support/concern'
+
+module ActiveAdmin
+
+  # Adds a class method to a class to create settings with default values.
+  #
+  # Example:
+  #
+  #   class Configuration
+  #     include ActiveAdmin::Settings
+  #
+  #     setting :site_title, "Default Site Title"
+  #
+  #     def initialize
+  #       # You must call this method to initialize the defaults
+  #       initialize_defaults!
+  #     end
+  #
+  module Settings
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+
+      def default_settings
+        self.class.default_settings
+      end
+
+    end
+
+    module ClassMethods
+
+      def setting(name, default)
+        default_settings[name] = default
+        attr_accessor(name)
+
+        # Create an accessor that grabs from the defaults
+        # if @name has not been set yet
+        class_eval <<-EOC, __FILE__, __LINE__ + 1
+          def #{name}
+            if instance_variable_defined? :@#{name}
+              @#{name}
+            else
+              default_settings[:#{name}]
+            end
+          end
+        EOC
+      end
+
+      def deprecated_setting(name, default, message = nil)
+        message = message || "The #{name} setting is deprecated and will be removed."
+        setting(name, default)
+
+        ActiveAdmin::Deprecation.deprecate self, name, message
+        ActiveAdmin::Deprecation.deprecate self, :"#{name}=", message
+      end
+
+      def default_settings
+        @default_settings ||= {}
+      end
+
+    end
+  end
+end