activeadmin-orac 1.0.0.pre4

data/docs/4-csv-format.md

@@ -0,0 +1,58 @@
+# Customizing the CSV format
+
+Active Admin provides CSV file downloads on the index screen for each Resource.
+By default it will render a CSV file with all the content columns of your
+registered model.
+
+Customizing the CSV format is as simple as customizing the index page.
+
+```ruby
+ActiveAdmin.register Post do
+  csv do
+    column :title
+    column(:author) { |post| post.author.full_name }
+    column('bODY', humanize_name: false) # preserve case
+  end
+end
+```
+
+You can also set custom CSV settings for an individual resource:
+
+```ruby
+ActiveAdmin.register Post do
+  csv force_quotes: true, col_sep: ';', column_names: false do
+    column :title
+    column(:author) { |post| post.author.full_name }
+  end
+end
+```
+
+Or system-wide:
+
+```ruby
+# config/initializers/active_admin.rb
+
+# Set the CSV builder separator
+config.csv_options = { col_sep: ';' }
+
+# Force the use of quotes
+config.csv_options = { force_quotes: true }
+```
+
+## Streaming
+
+By default Active Admin streams the CSV response to your browser as it's generated.
+This is good because it prevents request timeouts, for example the infamous H12
+error on Heroku.
+
+However if an exception occurs while generating the CSV, the request will eventually
+time out, with the last line containing the exception message. CSV streaming is
+disabled in development to help debug these exceptions. That lets you use tools like
+better_errors and web-console to debug the issue. If you want to customize the
+environments where CSV streaming is disabled, you can change this setting:
+
+```ruby
+# config/initializers/active_admin.rb
+
+config.disable_streaming_in = ['development', 'staging']
+```

data/docs/5-forms.md

@@ -0,0 +1,172 @@
+# Forms
+
+Active Admin gives you complete control over the output of the form by creating
+a thin DSL on top of [Formtastic](https://github.com/justinfrench/formtastic):
+
+```ruby
+ActiveAdmin.register Post do
+
+  form title: 'A custom title' do |f|
+    inputs 'Details' do
+      input :title
+      input :published_at, label: "Publish Post At"
+      li "Created at #{f.object.created_at}" unless f.object.new_record?
+      input :category
+    end
+    panel 'Markup' do
+      "The following can be used in the content below..."
+    end
+    inputs 'Content', :body
+    para "Press cancel to return to the list without saving."
+    actions
+  end
+
+end
+```
+
+For more details, please see Formtastic's documentation.
+
+## Default
+
+Resources come with a default form defined as such:
+
+```ruby
+form do |f|
+  f.semantic_errors # shows errors on :base
+  f.inputs          # builds an input field for every attribute
+  f.actions         # adds the 'Submit' and 'Cancel' buttons
+end
+```
+
+## Partials
+
+If you want to split a custom form into a separate partial use:
+
+```ruby
+ActiveAdmin.register Post do
+  form partial: 'form'
+end
+```
+
+Which looks for something like this:
+
+```ruby
+# app/views/admin/posts/_form.html.arb
+insert_tag active_admin_form_for resource do |f|
+  inputs :title, :body
+  actions
+end
+```
+
+This is a regular Rails partial so any template engine may be used.
+
+You can also use the `ActiveAdmin::FormBuilder` as builder in your Formtastic Form for use the same helpers are used in the admin file:
+
+```ruby
+  = semantic_form_for [:admin, @post], builder: ActiveAdmin::FormBuilder do |f|
+    = f.inputs "Details" do
+      = f.input :title
+    - f.has_many :taggings, sortable: :position, sortable_start: 1 do |t|
+      - t.input :tag
+    = f.actions
+
+```
+
+## Nested Resources
+
+You can create forms with nested models using the `has_many` method, even if your model uses `has_one`:
+
+```ruby
+ActiveAdmin.register Post do
+
+  form do |f|
+    f.inputs 'Details' do
+      f.input :title
+      f.input :published_at, label: 'Publish Post At'
+    end
+    f.inputs 'Content', :body
+    f.inputs do
+      f.has_many :categories, heading: 'Themes', allow_destroy: true, new_record: false do |a|
+        a.input :title
+      end
+    end
+    f.inputs do
+      f.has_many :taggings, sortable: :position, sortable_start: 1 do |t|
+        t.input :tag
+      end
+    end
+    f.inputs do
+      f.has_many :comment, new_record: 'Leave Comment',
+        allow_destroy: proc { |comment| comment.author?(current_admin_user) } do |b|
+        b.input :body
+      end
+    end
+    f.actions
+  end
+
+end
+```
+
+The `:allow_destroy` option adds a checkbox to the end of the nested form allowing
+removal of the child object upon submission. Be sure to set `allow_destroy: true`
+on the association to use this option. It is possible to associate `:allow_destroy` with a string or a symbol, corresponding to the name of a child object's method that will get called, or with a Proc object. The Proc object receives the child object as a parameter and should return either true or false.
+
+The `:heading` option adds a custom heading. You can hide it entirely by passing `false`.
+
+The `:new_record` option controls the visibility of the new record button (shown by default).
+If you pass a string, it will be used as the text for the new record button.
+
+The `:sortable` option adds a hidden field and will enable drag & drop sorting of the children. It
+expects the name of the column that will store the index of each child.
+
+The `:sortable_start` option sets the value (0 by default) of the first position in the list.
+
+## Datepicker
+
+ActiveAdmin offers the `datepicker` input, which uses the [jQuery UI datepicker](http://jqueryui.com/datepicker/).
+The datepicker input accepts any of the options available to the standard jQueryUI Datepicker. For example:
+
+```ruby
+form do |f|
+  f.input :starts_at, as: :datepicker, datepicker_options: { min_date: "2013-10-8",        max_date: "+3D" }
+  f.input :ends_at,   as: :datepicker, datepicker_options: { min_date: 3.days.ago.to_date, max_date: "+1W +5D" }
+end
+```
+
+## Displaying Errors
+
+To display a list of all validation errors:
+
+```ruby
+form do |f|
+  f.semantic_errors *f.object.errors.keys
+  # ...
+end
+```
+
+This is particularly useful to display errors on virtual or hidden attributes.
+
+# Tabs
+
+You can arrange content in tabs as shown below:
+
+```ruby
+  form do |f|
+    tabs do
+      tab 'Basic' do
+        f.inputs 'Basic Details' do
+          f.input :email
+          f.input :password
+          f.input :password_confirmation
+        end
+      end
+
+      tab 'Advanced' do
+        f.inputs 'Advanced Details' do
+          f.input :role
+        end
+      end
+    end
+    f.actions
+  end
+```

data/docs/6-show-pages.md

@@ -0,0 +1,105 @@
+# Customize the Show Page
+
+The show block is rendered within the context of the view and uses [Arbre](https://github.com/activeadmin/arbre) syntax.
+
+With the `show` block, you can render anything you want.
+
+```ruby
+ActiveAdmin.register Post do
+  show do
+    h3 post.title
+    div do
+      simple_format post.body
+    end
+  end
+end
+```
+
+You can render a partial at any point:
+
+```ruby
+ActiveAdmin.register Post do
+  show do
+    # renders app/views/admin/posts/_some_partial.html.erb
+    render 'some_partial', { post: post }
+  end
+end
+```
+
+If you'd like to keep the default AA look, you can use `attributes_table`:
+
+```ruby
+ActiveAdmin.register Ad do
+  show do
+    attributes_table do
+      row :title
+      row :image do |ad|
+        image_tag ad.image.url
+      end
+    end
+    active_admin_comments
+  end
+end
+```
+
+You can also customize the title of the object in the show screen:
+
+```ruby
+show title: :name do
+  # ...
+end
+```
+
+If you want a more data-dense page, you can combine a sidebar:
+
+```ruby
+ActiveAdmin.register Book do
+  show do
+    panel "Table of Contents" do
+      table_for book.chapters do
+        column :number
+        column :title
+        column :page
+      end
+    end
+    active_admin_comments
+  end
+
+  sidebar "Details", only: :show do
+    attributes_table_for book do
+      row :title
+      row :author
+      row :publisher
+      row('Published?') { |b| status_tag b.published? }
+    end
+  end
+end
+```
+
+# Tabs
+
+You can arrange content in tabs as shown below:
+
+```ruby
+  ActiveAdmin.register Order do 
+    show do
+      tabs do
+        tab 'Overview' do
+          attributes_table do
+            row(:status) { status_tag(order.status) }
+            row(:paid) { number_to_currency(order.amount_paid_in_dollars) }
+          end
+        end
+        
+        tab 'Payments' do
+          table_for order.payments do
+            column('Payment Type') { |p| p.payment_type.titleize }
+            column('Received On', :created_at)
+            column('Payment Details & Notes', :notes)
+            column('Amount') { |p| number_to_currency(p.amount_in_dollars) }
+          end
+        end
+      end
+    end
+  end
+```

data/docs/7-sidebars.md

@@ -0,0 +1,71 @@
+# Sidebar Sections
+
+Sidebars allow you to put whatever content you want on the side the page.
+
+```ruby
+sidebar :help do
+  "Need help? Email us at help@example.com"
+end
+```
+
+This will generate a sidebar on every page for that resource. The first
+argument is used as the title, and can be a symbol, string, or lambda.
+
+You can also use [Arbre](https://github.com/activeadmin/arbre) to define HTML content.
+
+```ruby
+sidebar :help do
+  ul do
+    li "Second List First Item"
+    li "Second List Second Item"
+  end
+end
+```
+
+Sidebars can be rendered on a specific action by passing `:only` or `:except`.
+
+```ruby
+sidebar :help, only: :index do
+  "Need help? Email us at help@example.com"
+end
+```
+
+If you want to conditionally display a sidebar section, use the :if option and
+pass it a proc which will be rendered within the view context.
+
+```ruby
+sidebar :help, if: proc{ current_admin_user.super_admin? } do
+  "Only for super admins!"
+end
+```
+
+You can access your model as resource in the sidebar too:
+
+```ruby
+sidebar :custom, only: :show do
+  resource.a_method
+end
+```
+
+You can also render a partial:
+
+```ruby
+sidebar :help                    # app/views/admin/posts/_help_sidebar.html.erb
+sidebar :help, partial: 'custom' # app/views/admin/posts/_custom.html.erb
+```
+
+It's possible to add custom class name to the sidebar parent element by passing
+`class` option:
+
+```ruby
+sidebar :help, class: 'custom_class'
+```
+
+By default sidebars are positioned in the same order as they defined, but it's also
+possible to specify their position manually:
+
+```ruby
+sidebar :help, priority: 0 # will push Help section to the top (above default Filters section)
+```
+
+Default sidebar priority is `10`.

data/docs/8-custom-actions.md

@@ -0,0 +1,160 @@
+# Custom Controller Actions
+
+Active Admin allows you to override and modify the underlying controller which
+is generated for you. There are helpers to add collection and member actions, or
+you can drop right in to the controller and modify its behavior.
+
+## Collection Actions
+
+A collection action is a controller action which operates on the collection of
+resources. This method adds both the action to the controller as well as
+generating a route for you.
+
+To add a collection action, use the collection_action method:
+
+```ruby
+ActiveAdmin.register Post do
+
+  collection_action :import_csv, method: :post do
+    # Do some CSV importing work here...
+    redirect_to collection_path, notice: "CSV imported successfully!"
+  end
+
+end
+```
+
+This collection action will generate a route at `/admin/posts/import_csv`
+pointing to the `Admin::PostsController#import_csv` controller action.
+
+## Member Actions
+
+A member action is a controller action which operates on a single resource.
+
+For example, to add a lock action to a user resource, you would do the
+following:
+
+```ruby
+ActiveAdmin.register User do
+
+  member_action :lock, method: :put do
+    resource.lock!
+    redirect_to resource_path, notice: "Locked!"
+  end
+
+end
+```
+
+This will generate a route at `/admin/users/:id/lock` pointing to the
+`Admin::UserController#lock` controller action.
+
+## HTTP Verbs
+
+The `collection_action` and `member_action` methods both accept the `:method`
+argument to set the HTTP verb for the controller action and route.
+
+Sometimes you want to create an action with the same name, that handles multiple
+HTTP verbs. In that case, this is the suggested approach:
+
+```ruby
+member_action :foo, method: [:get, :post] do
+  if request.post?
+    resource.update_attributes! foo: params[:foo] || {}
+    head :ok
+  else
+    render :foo
+  end
+end
+```
+
+## Rendering
+
+Custom controller actions support rendering within the standard Active Admin
+layout.
+
+```ruby
+ActiveAdmin.register Post do
+
+  # /admin/posts/:id/comments
+  member_action :comments do
+    @comments = resource.comments
+    # This will render app/views/admin/posts/comments.html.erb
+  end
+
+end
+```
+
+If you would like to use the same view syntax as the rest of Active Admin, you
+can use the Arbre file extension: .arb.
+
+For example, create `app/views/admin/posts/comments.html.arb` with:
+
+```ruby
+table_for assigns[:post].comments do
+  column :id
+  column :author
+  column :body do |comment|
+    simple_format comment.body
+  end
+end
+```
+
+## Page Titles
+
+The page title for the custom action will be the translated version of
+the controller action name. For example, a member_action named "upload_csv" will
+look up a translation key of `active_admin.upload_csv`. If none are found, it
+defaults to the name of the controller action.
+
+If this doesn't work for you, you can always set the `@page_title` instance
+variable in your controller action to customize the page title.
+
+```ruby
+ActiveAdmin.register Post do
+
+  member_action :comments do
+    @comments   = resource.comments
+    @page_title = "#{resource.title}: Comments" # Sets the page title
+  end
+
+end
+```
+
+# Action Items
+
+To include your own action items (like the New, Edit and Delete buttons), add an
+`action_item` block. The first parameter is just a name to identify the action,
+and is required. For example, to add a "View on site" button to view a blog
+post:
+
+```ruby
+action_item :view, only: :show do
+  link_to 'View on site', post_path(post) if post.published?
+end
+```
+
+Actions items also accept the `:if` option to conditionally display them:
+
+```ruby
+action_item :super_action, only: :show, if: proc{ current_admin_user.super_admin? } do
+  "Only display this to super admins on the show screen"
+end
+```
+
+# Modifying the Controller
+
+The generated controller is available to you within the registration block by
+using the `controller` method.
+
+```ruby
+ActiveAdmin.register Post do
+
+  controller do
+    # This code is evaluated within the controller class
+
+    def define_a_method
+      # Instance method
+    end
+  end
+
+end
+```