activeadmin 0.6.6 → 1.0.0.pre1

data/docs/12-arbre-components.md

@@ -10,19 +10,23 @@ non-breaking space or some text. The text_node method can be used to insert
 these elements into the page inside of other Arbre components or resource
 controller functions.
 
-    ActiveAdmin.register Post do
-      show do
-        panel "Post Details" do
-          row("") { post.id }
-          row("Tags") do
-            text_node link_to "#{tag}",
-              admin_post_path( q: { tagged_with_contains: tag } )
+```ruby
+ActiveAdmin.register Post do
+  show do
+    panel "Post Details" do
+      attributes_table_for post do
+        row :id
+        row 'Tags' do
+          post.tags.each do |tag|
+            a tag, href: admin_post_path(q: {tagged_with_contains: tag})          
             text_node "&nbsp".html_safe
           end
         end
       end
     end
-
+  end
+end
+```
 
 ## Panels
 
@@ -30,19 +34,19 @@ A panel is a component that takes up all available horizontal space and takes a
 title and a hash of attributes as arguments. If a sidebar is present, a panel
 will take up the remaining space.
 
-The following code will create two stacked panels:
-
-    show do
+This will create two stacked panels:
 
-      panel "Post Details" do
-        render partial: "show_details", locals: {post: post}
-      end
-
-      panel "Post Tags" do
-        render partial: "show_enhancements", locals: {post: post}
-      end
+```ruby
+show do
+  panel "Post Details" do
+    render partial: "details", locals: {post: post}
+  end
 
-    end
+  panel "Post Tags" do
+    render partial: "tags",    locals: {post: post}
+  end
+end
+```
 
 ## Columns
 
@@ -52,34 +56,36 @@ the rest.
 
 #### Simple Columns
 
-To create simple columnns, use the #columns method. Within the block, call
+To create simple columnns, use the `columns` method. Within the block, call
 the #column method to create a new column.
 
-    columns do
-
-      column do
-        span "Column #1"
-      end
-
-      column do
-        span "Column #2"
-      end
+```ruby
+columns do
+  column do
+    span "Column #1"
+  end
 
-    end
+  column do
+    span "Column #2"
+  end
+end
+```
 
-### Spannig Multiple Columns
+### Spanning Multiple Columns
 
 To create columns that have multiple spans, pass the :span option to the column
 method.
 
-    columns do
-      column :span => 2 do
-        span "Column # 1"
-      end
-      column do
-        span "Column # 2"
-      end
-    end
+```ruby
+columns do
+  column span: 2 do
+    span "Column # 1"
+  end
+  column do
+    span "Column # 2"
+  end
+end
+```
 
 By default, each column spans 1 column. The above layout would have 2 columns,
 the first being twice as large as the second.
@@ -89,16 +95,18 @@ the first being twice as large as the second.
 Active Admin uses a fluid width layout, causing column width to be defined
 using percentages. Due to using this style of layout, columns can shrink or
 expand past points that may not be desirable. To overcome this issue,
-columns provide :max_width and :min_width options.
-
-    columns do
-      column :max_width => "200px", :min_width => "100px" do
-        span "Column # 1"
-      end
-      column do
-        span "Column # 2"
-      end
-    end
+columns provide `:max_width` and `:min_width` options.
+
+```ruby
+columns do
+  column max_width: "200px", min_width: "100px" do
+    span "Column # 1"
+  end
+  column do
+    span "Column # 2"
+  end
+end
+```
 
 In the above example, the first column will not grow larger than 200px and will
 not shrink less than 100px.
@@ -106,39 +114,37 @@ not shrink less than 100px.
 ## Table For
 
 Table For provides the ability to create tables like those present
-in #index_as_table. table_for takes a collection and a hash of options and then
-uses #column to build the fields to show with the table.
-
-    table_for order.payments do
-      column "Payment Type" { |payment| payment.payment_type.titleize }
-      column "Received On", :created_at
-      column "Payment Details & Notes", :payment_details
-      column "Amount" { |payment| payment.amount_in_dollars }
-    end
-
-the #column method can take a title as its first argument and data
-(:your_method) as its second (or first if no title provided). Column also
+in `index_as_table`. It takes a collection and a hash of options and then
+uses `column` to build the fields to show with the table.
+
+```ruby
+table_for order.payments do
+  column(:payment_type) { |payment| payment.payment_type.titleize }
+  column "Received On",     :created_at
+  column "Details & Notes", :payment_details
+  column "Amount",          :amount_in_dollars
+end
+```
+
+the `column` method can take a title as its first argument and data
+(`:your_method`) as its second (or first if no title provided). Column also
 takes a block.
 
 ## Status tag
 
 Status tags provide convenient syntactic sugar for styling items that have
 status. A common example of where the status tag could be useful is for orders
-that are complete or in progress. status_tag takes a status, like
+that are complete or in progress. `status_tag` takes a status, like
 "In Progress", a type, which defaults to nil, and a hash of options. The
 status_tag will generate html markup that Active Admin css uses in styling.
 
-    status_tag('In Progress')
-    # => <span class='status_tag in_progress'>In Progress</span>
+```ruby
+status_tag 'In Progress'
+# => <span class='status_tag in_progress'>In Progress</span>
 
-    status_tag('active', :ok)
-    # => <span class='status_tag active ok'>Active</span>
+status_tag 'active', :ok
+# => <span class='status_tag active ok'>Active</span>
 
-    status_tag (
-      'active',
-      :ok,
-      :class => 'important',
-      :id => 'status_123',
-      :label => 'on'
-    )
-    # => <span class='status_tag active ok important' id='status_123'>on</span>
+status_tag 'active', :ok, class: 'important', id: 'status_123', label: 'on'
+# => <span class='status_tag active ok important' id='status_123'>on</span>
+```

data/docs/13-authorization-adapter.md

@@ -4,68 +4,69 @@ Active Admin offers the ability to define and use your own authorization
 adapter. If implemented, the '#authorized?' will be called when an action is
 taken. By default, '#authorized?' returns true.
 
-
 ## Setting up your own AuthorizationAdapter
 
 Setting up your own `AuthorizationAdapter` is easy! The following example shows
 how to set up and tie your authorization adapter class to Active Admin:
 
-    # app/models/only_authors_authorization.rb
-    class OnlyAuthorsAuthorization < ActiveAdmin::AuthorizationAdapter
-
-        def authorized?(action, subject = nil)
-          case subject
-          when normalized(Post)
-
-            # Only let the author update and delete posts
-            if action == :update || action == :destroy
-              subject.author == user
-
-            # If it's not an update or destroy, anyone can view it
-            else
-              true
-            end
-
-          else
-            true
-          end
-        end
-
+```ruby
+# app/models/only_authors_authorization.rb
+class OnlyAuthorsAuthorization < ActiveAdmin::AuthorizationAdapter
+
+  def authorized?(action, subject = nil)
+    case subject
+    when normalized(Post)
+      # Only let the author update and delete posts
+      if action == :update || action == :destroy
+        subject.author == user
+      else
+        true
+      end
+    else
+      true
     end
+  end
+
+end
+```
 
 In order to hook up `OnlyAuthorsAuthorization` to Active Admin, go to your
 application's `config/initializers/active_admin.rb` and add/modify the line:
 
-    config.authorization_adapter = "OnlyAuthorsAuthorization"
+```ruby
+config.authorization_adapter = "OnlyAuthorsAuthorization"
+```
 
 Authorization adapters can be configured per ActiveAdmin namespace as well, for example:
 
-    ActiveAdmin.setup do |config|
-      config.namespace :admin do |ns|
-        ns.authorization_adapter = "AdminAuthorization"
-      end
-      config.namespace :my do |ns|
-        ns.authorization_adapter = "DashboardAuthorization"
-      end
-    end
+```ruby
+ActiveAdmin.setup do |config|
+  config.namespace :admin do |ns|
+    ns.authorization_adapter = "AdminAuthorization"
+  end
+  config.namespace :my do |ns|
+    ns.authorization_adapter = "DashboardAuthorization"
+  end
+end
+```
 
 Now, whenever a controller action is performed, the `OnlyAuthorsAuthorization`'s
 `#authorized?` method will be called.
 
-
 ## Getting Access to the Current User
 
 From within your authorization adapter, you can call the `#user` method to
 retrieve the current user.
 
-    class OnlyAdmins < ActiveAdmin::AuthorizationAdapter
-
-      def authorized?(action, subject = nil)
-        user.admin?
-      end
+```ruby
+class OnlyAdmins < ActiveAdmin::AuthorizationAdapter
 
-    end
+  def authorized?(action, subject = nil)
+    user.admin?
+  end
 
+end
+```
 
 ## Scoping Collections in Authorization Adapters
 
@@ -73,42 +74,40 @@ retrieve the current user.
 for the adapter to scope the resource's collection. For example, you may want to
 centralize the scoping:
 
-    class OnlyMyAccount < ActiveAdmin::AuthorizationAdapter
+```ruby
+class OnlyMyAccount < ActiveAdmin::AuthorizationAdapter
 
-      def authorized?(action, subject = nil)
-        subject.account == user.account
-      end
+  def authorized?(action, subject = nil)
+    subject.account == user.account
+  end
 
-      def scope_collection(collection)
-        collection.where(:account_id => user.account_id)
-      end
+  def scope_collection(collection, action = Auth::READ)
+    collection.where(account_id: user.account_id)
+  end
 
-    end
+end
+```
 
 All collections presented on Index Screens will be passed through this method
 and will be scoped accordingly.
 
-
 ## Managing Access to Pages
 
 Pages, just like resources, get authorized also. When authorization a page, the
 subject will be an instance of `ActiveAdmin::Page`.
 
-    class OnlyDashboard < ActiveAdmin::AuthorizationAdapter
-      def authorized?(action, subject = nil)
-        case subject
-        when ActiveAdmin::Page
-          if action == :read && subject.name == "Dashboard"
-            true
-          else
-            false
-          end
-        else
-          false
-        end
-      end
+```ruby
+class OnlyDashboard < ActiveAdmin::AuthorizationAdapter
+  def authorized?(action, subject = nil)
+    case subject
+    when ActiveAdmin::Page
+      action == :read && subject.name == "Dashboard" && subject.namespace.name == :admin
+    else
+      false
     end
-
+  end
+end
+```
 
 ## Action Types
 
@@ -133,61 +132,66 @@ authorized to perform an action on a subject.
 
 Simply use the `#authorized?(action, subject) method to check.
 
-    ActiveAdmin.register Post do
-
-      index do
-        column :title
-        column "" do |post|
-          if authorized?(:update, post)
-            link_to("Edit", admin_post_path(post))
-          end
-        end
-
-      end
+```ruby
+ActiveAdmin.register Post do
 
+  index do
+    column :title
+    column '' do |post|
+      link_to 'Edit', admin_post_path(post) if authorized? :update, post
     end
+  end
+
+end
+```
 
 If you are implementing a custom controller action, you can use the
 `#authorize!` method to raise an `ActiveAdmin::AccessDenied` exception.
 
-    ActiveAdmin.register Post do
-
-      member_action :publish, :method => :post do
-        post = Post.find(params[:id])
+```ruby
+ActiveAdmin.register Post do
 
-        authorize! :publish, post
-        post.publish!
+  member_action :publish, method: :post do
+    post = Post.find(params[:id])
 
-        flash[:notice] = "Post has been published"
-        redirect_to [:admin, post]
-      end
+    authorize! :publish, post
+    post.publish!
 
-      action_item :only => :show do
-        if !post.published? && authorized?(:publish, post)
-          link_to("Publish", publish_admin_post_path(post), :method => :post)
-        end
-      end
+    flash[:notice] = "Post has been published"
+    redirect_to [:admin, post]
+  end
 
+  action_item :publish, only: :show do
+    if !post.published? && authorized?(:publish, post)
+      link_to "Publish", publish_admin_post_path(post), method: :post
     end
+  end
 
+end
+```
 
 ## Using the CanCan Adapter
 
 Sub-classing `ActiveAdmin::AuthorizationAdapter` is fairly low level. Many times
 it's nicer to have a simpler DSL for managing authorization. Active Admin
-provides an adapter out of the box for [CanCan](https://github.com/ryanb/cancan).
+provides an adapter out of the box for [CanCan](https://github.com/ryanb/cancan)
+and [CanCanCan](https://github.com/CanCanCommunity/cancancan).
 
 To use the CanCan adapter, simply update the configuration in the Active Admin
 initializer:
 
-    config.authorization_adapter = ActiveAdmin::CanCanAdapter
-    
+```ruby
+config.authorization_adapter = ActiveAdmin::CanCanAdapter
+```
+
 You can also specify a method to be called on unauthorized access. This is necessary
 in order to prevent a redirect loop that can happen if a user tries to access a page
-they don't have permissions for (see [#2081](https://github.com/gregbell/active_admin/issues/2081)).
+they don't have permissions for (see [#2081](https://github.com/activeadmin/activeadmin/issues/2081)).
+
 ```ruby
 config.on_unauthorized_access = :access_denied
-```    
+```
+
 The method `access_denied` would be defined in `application_controller.rb`. Here is one
 example that redirects the user from the page they don't have permission to
 access to a resource they have permission to access (organizations in this case), and
@@ -196,9 +200,9 @@ also displays the error message in the browser:
 ```ruby
 class ApplicationController < ActionController::Base
   protect_from_forgery
-  
+
   def access_denied(exception)
-    redirect_to admin_organizations_path, :alert => exception.message
+    redirect_to admin_organizations_path, alert: exception.message
   end
 end
 ```
@@ -206,22 +210,39 @@ end
 By default this will use the ability class named "Ability". This can also be
 changed from the initializer:
 
-    config.cancan_ability_class = "MyCustomAbility"
+```ruby
+config.cancan_ability_class = "MyCustomAbility"
+```
 
-Now you can simply use CanCan the way that you would expect and Active Admin
-will use it for authorization:
+Now you can simply use CanCan or CanCanCan the way that you would expect and
+Active Admin will use it for authorization:
 
-    # app/models/ability.rb
-    class Ability
-      include CanCan::Ability
+```ruby
+# app/models/ability.rb
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    can :manage, Post
+    can :read, User
+    can :manage, User, id: user.id
+    can :read, ActiveAdmin::Page, name: "Dashboard", namespace_name: :admin
+  end
 
-      def initialize(user)
-        can :manage, Post
-        can :read, User
-        can :manage, User, :id => user.id
-        can :read, ActiveAdmin::Page, :name => "Dashboard"
-      end
+end
+```
 
-    end
+To view more details about the API's, visit project pages of [CanCan](https://github.com/ryanb/cancan) and [CanCanCan](https://github.com/CanCanCommunity/cancancan).
+
+## Using the Pundit Adapter
+
+Active Admin provides an adapter out of the box also for [Pundit](https://github.com/elabs/pundit).
+
+To use the Pundit adapter, simply update the configuration in the Active Admin
+initializer:
+
+```ruby
+config.authorization_adapter = ActiveAdmin::PunditAdapter
+```
 
-To view more details about the CanCan API, visit [https://github.com/ryanb/cancan](https://github.com/ryanb/cancan).
+You can simply use Pundit the way that you would expect and Active Admin will use it for authorization. Check Pundit's documentation to [set up Pundit in your application](https://github.com/elabs/pundit#installation). If you want to use batch actions just ensure that `destroy_all?` method is defined in your policy class. You can use this [template policy](https://github.com/activeadmin/activeadmin/blob/master/spec/support/templates/policies/application_policy.rb) in your application instead of default one generated by Pundit's `rails g pundit:install` command.