activeadmin 0.6.6 → 1.0.0.pre1

data/spec/unit/views/pages/form_spec.rb

@@ -1,34 +1,41 @@
-require "spec_helper"
+require 'rails_helper'
 
 describe ActiveAdmin::Views::Pages::Form do
   describe "#title" do
     let!(:application){ ActiveAdmin::Application.new }
     let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
-    let!(:params){ { :controller => "UsersController", :action => "edit" } }
+    let!(:params){ { controller: "UsersController", action: "edit" } }
     let(:helpers) do
       helpers = mock_action_view
-      helpers.stub :active_admin_config => namespace.register(Post),
-                   :params => params
-
+      allow(helpers).to receive(:active_admin_config).and_return(namespace.register(Post))
+      allow(helpers).to receive(:params).and_return(params)
       helpers
     end
 
     let(:arbre_context) do
-      OpenStruct.new(:params => params, :helpers => helpers, :assigns => {})
+      OpenStruct.new(params: params, helpers: helpers, assigns: {})
     end
 
     context "when page_title is assigned" do
       it "should show the set page title" do
         arbre_context.assigns[:page_title] = "My Page Title"
         page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
-        page.title.should eq "My Page Title"
+        expect(page.title).to eq "My Page Title"
       end
     end
 
     context "when page_title is not assigned" do
-      it "should show the correct I18n text" do
-        page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
-        page.title.should eq "Edit Post"
+      {
+        "new" => "New Post",
+        "create" => "New Post",
+        "edit" => "Edit Post",
+        "update" => "Edit Post"
+      }.each do |action, title|
+        it "should show the correct I18n text on the #{action} action" do
+          params[:action] = action
+          page = ActiveAdmin::Views::Pages::Form.new(arbre_context)
+          expect(page.title).to eq title
+        end
       end
     end
   end

data/spec/unit/views/pages/index_spec.rb

@@ -0,0 +1,60 @@
+require 'rails_helper'
+
+describe ActiveAdmin::Views::Pages::Index do
+  describe "#title" do
+    let!(:application){ ActiveAdmin::Application.new }
+    let(:namespace){ ActiveAdmin::Namespace.new(application, "Admin") }
+    let!(:params){ { controller: "UsersController", action: "edit" } }
+    let(:helpers) do
+      helpers = mock_action_view
+      allow(helpers).to receive(:active_admin_config).and_return(namespace.register(Post))
+      allow(helpers).to receive(:params).and_return(params)
+      helpers
+    end
+
+    let(:arbre_context) do
+      OpenStruct.new(params: params, helpers: helpers, assigns: {})
+    end
+
+    context "when config[:title] is assigned" do
+      context "with a Proc" do
+        it "should return the value of the assigned Proc" do
+          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
+          allow(page).to receive(:config).and_return(title: ->{ "My Page Title" })
+          expect(page.title).to eq "My Page Title"
+        end
+      end
+
+      context "with a String" do
+        it "should return the assigned String" do
+          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
+          allow(page).to receive(:config).and_return(title: ->{ "My Page Title" })
+          expect(page.title).to eq "My Page Title"
+        end
+      end
+
+      context "with a Integer" do
+        it "should return the Integer" do
+          page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
+          allow(page).to receive(:config).and_return(title: 1)
+          expect(page.title).to eq 1
+        end
+      end
+    end
+
+    context "when page_title is assigned" do
+      it "should return the set page title" do
+        arbre_context.assigns[:page_title] = "My Page Title"
+        page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
+        expect(page.title).to eq "My Page Title"
+      end
+    end
+
+    context "when page_title is not assigned" do
+      it "should return the correct I18n text" do
+        page = ActiveAdmin::Views::Pages::Index.new(arbre_context)
+        expect(page.title).to eq "Posts"
+      end
+    end
+  end
+end

data/spec/unit/views/pages/layout_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'rails_helper'
 
 describe ActiveAdmin::Views::Pages::Layout do
 
@@ -6,22 +6,18 @@ describe ActiveAdmin::Views::Pages::Layout do
   let(:helpers) do
     helpers = mock_action_view
 
-    helpers.stub :active_admin_application => active_admin_application,
-                 :active_admin_config => mock('Config', :action_items? => nil, :breadcrumb => nil, :sidebar_sections? => nil),
-                 :active_admin_namespace => active_admin_namespace,
-                 :breadcrumb_links => [],
-                 :content_for => "",
-                 :csrf_meta_tag => "",
-                 :current_active_admin_user => nil,
-                 :current_active_admin_user? => false,
-                 :current_menu => mock('Menu', :items => []),
-                 :flash => {},
-                 :javascript_path => "/dummy/",
-                 :link_to => "",
-                 :render_or_call_method_or_proc_on => "",
-                 :stylesheet_link_tag => mock(:html_safe => ""),
-                 :view_factory => view_factory,
-                 :params => {:controller => 'UsersController', :action => 'edit'}
+    { active_admin_application:   active_admin_application,
+      active_admin_config:        double('Config', action_items?: nil, breadcrumb: nil, sidebar_sections?: nil),
+      active_admin_namespace:     active_admin_namespace,
+      csrf_meta_tag:              '',
+      current_active_admin_user:  nil,
+      current_active_admin_user?: false,
+      current_menu:               double('Menu', items: []),
+      params:                     {controller: 'UsersController', action: 'edit'},
+      env:                        {}
+    }.each do |method, returns|
+      allow(helpers).to receive(method).and_return returns
+    end
 
     helpers
   end
@@ -39,23 +35,23 @@ describe ActiveAdmin::Views::Pages::Layout do
   it "should be the @page_title if assigned in the controller" do
     assigns[:page_title] = "My Page Title"
 
-    layout.title.should == "My Page Title"
+    expect(layout.title).to eq "My Page Title"
   end
 
   it "should be the default translation" do
     helpers.params[:action] = "edit"
 
-    layout.title.should == "Edit"
+    expect(layout.title).to eq "Edit"
   end
 
   describe "the body" do
 
     it "should have class 'active_admin'" do
-      layout.build.class_list.should include 'active_admin'
+      expect(layout.build.class_list).to include 'active_admin'
     end
 
     it "should have namespace class" do
-      layout.build.class_list.should include "#{active_admin_namespace.name}_namespace"
+      expect(layout.build.class_list).to include "#{active_admin_namespace.name}_namespace"
     end
 
   end

data/spec/unit/views/pages/show_spec.rb

@@ -1,18 +1,30 @@
-require 'spec_helper'
-
+require 'rails_helper'
 
 describe ActiveAdmin::Views::Pages::Show do
 
   describe "the resource" do
-    let(:helpers) { mock(:resource => resource) }
-    let(:arbre_context) { OpenStruct.new(:helpers => helpers) }
+    let(:helpers) { double resource: resource }
+    let(:arbre_context) { Arbre::Context.new({}, helpers) }
+    subject(:page) { ActiveAdmin::Views::Pages::Show.new(arbre_context) }
 
     context 'when the resource does not respond to #decorator' do
       let(:resource) { 'Test Resource' }
 
       it "normally returns the resource" do
-        page = ActiveAdmin::Views::Pages::Show.new(arbre_context)
-        page.resource.should == 'Test Resource'
+        expect(page.resource).to eq 'Test Resource'
+      end
+    end
+
+    context 'when you pass a block to main content' do
+      let(:block) { lambda { } }
+      let(:resource_class) { double(columns: [double('column', name: 'field')]) }
+      let(:resource) { double('resource', class: resource_class) }
+
+      before { allow(page).to receive(:active_admin_config).and_return(double(comments?: false))}
+
+      it 'appends it to the output' do
+        expect(page).to receive(:attributes_table).with(:field).and_yield
+        page.default_main_content(&block)
       end
     end
 

data/spec/unit/views/tabbed_navigation_spec.rb

@@ -1,11 +1,11 @@
-require 'spec_helper'
+require 'rails_helper'
 
 include ActiveAdmin
 describe ActiveAdmin::Views::TabbedNavigation do
 
   let(:menu){ ActiveAdmin::Menu.new }
 
-  let(:assigns){ { :active_admin_menu => menu } }
+  let(:assigns){ { active_admin_menu: menu } }
   let(:helpers){ mock_action_view }
 
   let(:tabbed_navigation) do
@@ -14,99 +14,108 @@ describe ActiveAdmin::Views::TabbedNavigation do
     }.children.first
   end
 
-  let(:html) { tabbed_navigation.to_s }
+  let(:html) { Capybara.string(tabbed_navigation.to_s) }
 
   before do
-    helpers.stub!(:admin_logged_in?).and_return(false)
+    allow(helpers).to receive(:admin_logged_in?).and_return(false)
   end
 
   describe "rendering a menu" do
 
     before do
-      menu.add :label => "Blog Posts", :url => :admin_posts_path
+      menu.add label: "Blog Posts", url: :admin_posts_path
 
-      menu.add :label => "Reports", :url => "/admin/reports" do |reports|
-        reports.add :label => "A Sub Reports", :url => "/admin/a-sub-reports"
-        reports.add :label => "B Sub Reports", :url => "/admin/b-sub-reports"
-        reports.add :label => proc{ "Label Proc Sub Reports" }, :url => "/admin/label-proc-sub-reports", :id => "Label Proc Sub Reports"
+      menu.add label: "Reports", url: "/admin/reports" do |reports|
+        reports.add label: "A Sub Reports", url: "/admin/a-sub-reports"
+        reports.add label: "B Sub Reports", url: "/admin/b-sub-reports"
+        reports.add label: proc{ "Label Proc Sub Reports" }, url: "/admin/label-proc-sub-reports", id: "Label Proc Sub Reports"
       end
 
-      menu.add :label => "Administration", :url => "/admin/administration" do |administration|
-        administration.add :label => "User administration",
-                           :url => '/admin/user-administration',
-                           :priority => 10,
-                           :if => proc { false }
+      menu.add label: "Administration", url: "/admin/administration" do |administration|
+        administration.add label: "User administration",
+                           url: '/admin/user-administration',
+                           priority: 10,
+                           if: proc { false }
       end
 
-      menu.add :label => "Management", :url => "#" do |management|
-        management.add :label => "Order management",
-                       :url => '/admin/order-management',
-                       :priority => 10,
-                       :if => proc { false }
-        management.add :label => "Bill management",
-                       :url => '/admin/bill-management',
-                       :priority => 10,
-                       :if => :admin_logged_in?
+      menu.add label: "Management", url: "#" do |management|
+        management.add label: "Order management",
+                       url: '/admin/order-management',
+                       priority: 10,
+                       if: proc { false }
+        management.add label: "Bill management",
+                       url: '/admin/bill-management',
+                       priority: 10,
+                       if: :admin_logged_in?
       end
+
+      menu.add label: "Charles Smith", id: "current_user", url: -> { nil }
     end
 
     it "should generate a ul" do
-      html.should have_tag("ul")
+      expect(html).to have_selector("ul")
     end
 
     it "should generate an li for each item" do
-      html.should have_tag("li", :parent => { :tag => "ul" })
+      expect(html).to have_selector("ul > li")
     end
 
     it "should generate a link for each item" do
-      html.should have_tag("a", "Blog Posts", :attributes => { :href => '/admin/posts' })
+      expect(html).to have_selector("a[href='/admin/posts']", text: "Blog Posts")
     end
 
     it "should generate a nested list for children" do
-      html.should have_tag("ul", :parent => { :tag => "li" })
+      expect(html).to have_selector("li > ul")
     end
 
     it "should generate a nested list with li for each child" do
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "a_sub_reports"})
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "b_sub_reports"})
+      expect(html).to have_selector("ul > li#a_sub_reports")
+      expect(html).to have_selector("ul > li#b_sub_reports")
     end
 
     it "should generate a valid id from a label proc" do
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "label_proc_sub_reports"})
+      expect(html).to have_selector("ul > li#label_proc_sub_reports")
     end
 
     it "should not generate a link for user administration" do
-      html.should_not have_tag("a", "User administration", :attributes => { :href => '/admin/user-administration' })
+      expect(html).to_not have_selector("a[href='/admin/user-administration']", text: "User administration")
     end
 
     it "should generate the administration parent menu" do
-      html.should have_tag("a", "Administration", :attributes => { :href => '/admin/administration' })
+      expect(html).to have_selector("a[href='/admin/administration']", text: "Administration")
     end
 
     it "should not generate a link for order management" do
-      html.should_not have_tag("a", "Order management", :attributes => { :href => '/admin/order-management' })
+      expect(html).to_not have_selector("a[href='/admin/order-management']", text: "Order management")
     end
 
     it "should not generate a link for bill management" do
-      html.should_not have_tag("a", "Bill management", :attributes => { :href => '/admin/bill-management' })
+      expect(html).to_not have_selector("a[href='/admin/bill-management']", text: "Bill management")
     end
 
     it "should not generate the management parent menu" do
-      html.should_not have_tag("a", "Management", :attributes => { :href => '#' })
+      expect(html).to_not have_selector("a[href='#']", text: "Management")
+    end
+
+    context "when url is nil" do
+      it "should generate a span" do
+        selector = "li#current_user > span"
+        expect(html).to have_selector(selector, text: "Charles Smith")
+      end
     end
 
     describe "marking current item" do
 
       it "should add the 'current' class to the li" do
         assigns[:current_tab] = menu["Blog Posts"]
-        html.should have_tag("li", :attributes => { :class => "current" })
+        expect(html).to have_selector("li.current")
       end
 
       it "should add the 'current' and 'has_nested' classes to the li and 'current' to the sub li" do
         assigns[:current_tab] = menu["Reports"]["A Sub Reports"]
-        html.should have_tag("li", :attributes => { :id => "reports", :class => /current/ })
-        html.should have_tag("li", :attributes => { :id => "reports", :class => /has_nested/ })
-        html.should have_tag("li", :attributes => { :id => "a_sub_reports", :class => "current" })
+        expect(html).to have_selector("li#reports.current")
+        expect(html).to have_selector("li#reports.has_nested")
+        expect(html).to have_selector("li#a_sub_reports.current")
       end
 
     end
@@ -116,33 +125,33 @@ describe ActiveAdmin::Views::TabbedNavigation do
   describe "returning the menu items to display" do
 
     it "should return one item with no if block" do
-      menu.add :label => "Hello World", :url => "/"
-      tabbed_navigation.menu_items.should == menu.items
+      menu.add label: "Hello World", url: "/"
+      expect(tabbed_navigation.menu_items).to eq menu.items
     end
 
     it "should not include menu items with an if block that returns false" do
-      menu.add :label => "Don't Show", :url => "/", :priority => 10, :if => proc{ false }
-      tabbed_navigation.menu_items.should be_empty
+      menu.add label: "Don't Show", url: "/", priority: 10, if: proc{ false }
+      expect(tabbed_navigation.menu_items).to be_empty
     end
 
     it "should not include menu items with an if block that calls a method that returns false" do
-      menu.add :label => "Don't Show", :url => "/", :priority => 10, :if => :admin_logged_in?
-      tabbed_navigation.menu_items.should be_empty
+      menu.add label: "Don't Show", url: "/", priority: 10, if: :admin_logged_in?
+      expect(tabbed_navigation.menu_items).to be_empty
     end
 
     it "should not display any items that have no children to display" do
-      menu.add :label => "Parent", :url => "#" do |p|
-        p.add :label => "Child", :url => "/", :priority => 10, :if => proc{ false }
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Child", url: "/", priority: 10, if: proc{ false }
       end
-      tabbed_navigation.menu_items.should be_empty
+      expect(tabbed_navigation.menu_items).to be_empty
     end
 
     it "should display a parent that has a child to display" do
-      menu.add :label => "Parent", :url => "#" do |p|
-        p.add :label => "Hidden Child", :url => "/", :priority => 10, :if => proc{ false }
-        p.add :label => "Child", :url => "/"
+      menu.add label: "Parent", url: "#" do |p|
+        p.add label: "Hidden Child", url: "/", priority: 10, if: proc{ false }
+        p.add label: "Child", url: "/"
       end
-      tabbed_navigation.should have(1).menu_items
+      expect(tabbed_navigation.menu_items.size).to eq(1)
     end
 
   end

data/tasks/docs.rake

@@ -1,24 +1,22 @@
 namespace :docs do
 
-  def rdoc_to_markdown(content)
-    content.gsub(/^ ?(=+) /) do |m|
-      m.gsub('=', '#')
-    end
-  end
+  AUTOGEN_WARNING = <<-EOD
+<!--
+  WARNING: Please DO NOT edit this file! Update
+  source documentation in lib/active_admin/views
+  and execute rake yard to regenerate it.
+-->
 
-  def prepare_docstring(content)
-    content = rdoc_to_markdown(content)
-    "<!-- Please don't edit this file. It will be clobbered. -->\n\n#{content}"
-  end
+EOD
 
   def filename_from_module(mod)
-    mod.name.to_s.underscore.gsub('_', '-')
+    mod.name.to_s.underscore.tr('_', '-')
   end
 
   def write_docstrings_to(path, mods)
     mods.each do |mod|
       File.open("#{path}/#{filename_from_module(mod)}.md", 'w+') do |f|
-        f << prepare_docstring(mod.docstring)
+        f << AUTOGEN_WARNING + mod.docstring + "\n"
       end
     end
   end