lalala 4.0.0.dev.141 → 4.0.0.dev.144

data/vendor/deps/active_admin/spec/unit/menu_item_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper_without_rails'
-require 'active_admin/menu'
-require 'active_admin/menu_item'
-
-module ActiveAdmin
-  describe MenuItem do
-
-    it "should have a label" do
-      item = MenuItem.new(:label => "Dashboard")
-      item.label.should == "Dashboard"
-    end
-
-    it "should have a url" do
-      item = MenuItem.new(:url => "/admin")
-      item.url.should == "/admin"
-    end
-
-    it "should have a priority of 10 by default" do
-      item = MenuItem.new
-      item.priority.should == 10
-    end
-
-    it "should have a display if block" do
-      block = lambda{ logged_in? }
-      item = MenuItem.new(:if => block )
-      item.display_if_block.should == block
-    end
-
-    it "should have a default display if block always returning true" do
-      item = MenuItem.new
-      item.display_if_block.should be_instance_of(Proc)
-      item.display_if_block.call(self).should == true
-    end
-
-    it "should default to an empty hash for html_options" do
-      item = MenuItem.new
-      item.html_options.should be_empty
-    end
-
-    it "should accept an options hash for link_to" do
-      item = MenuItem.new :html_options => { :target => :blank }
-      item.html_options.should include(:target => :blank)
-    end
-
-    context "with no items" do
-      it "should be empty" do
-        item = MenuItem.new
-        item.items.should == []
-      end
-
-      it "should accept new children" do
-        item = MenuItem.new
-        item.add :label => "Dashboard"
-        item.items.first.should be_an_instance_of(MenuItem)
-        item.items.first.label.should == "Dashboard"
-      end
-    end
-
-    context "with many children" do
-      let(:item) do
-        i = MenuItem.new(:label => "Dashboard")
-        i.add :label => "Blog"
-        i.add :label => "Cars"
-        i.add :label => "Users", :priority => 1
-        i.add :label => "Settings", :priority => 2
-        i.add :label => "Analytics", :priority => 44
-        i
-      end
-
-      it "should give access to the menu item as an array" do
-        item['Blog'].label.should == 'Blog'
-      end
-
-      it "should sort items based on priority and name" do    
-        item.items[0].label.should == 'Users'
-        item.items[1].label.should == 'Settings'
-        item.items[2].label.should == 'Blog'
-        item.items[3].label.should == 'Cars'
-        item.items[4].label.should == 'Analytics'
-      end
-
-      it "children should hold a reference to their parent" do
-        item["Blog"].parent.should == item
-      end
-    end
-
-    describe "accessing ancestory" do
-      let(:item){ MenuItem.new :label => "Blog" }
-
-      context "with no parent" do
-        it "should return an empty array" do
-         item.ancestors.should == [] 
-        end
-      end
-
-      context "with one parent" do
-        let(:sub_item) do 
-          item.add :label => "Create New"
-          item["Create New"]
-        end
-        it "should return an array with the parent" do
-          sub_item.ancestors.should == [item]
-        end
-      end
-
-      context "with many parents" do
-        before(:each) do
-          c1 = {:label => "C1"}
-          c2 = {:label => "C2"}
-          c3 = {:label => "C3"}
-
-          item.add(c1).add(c2).add(c3)
-
-          item
-        end
-        let(:sub_item){ item["C1"]["C2"]["C3"] }
-        it "should return an array with the parents in reverse order" do
-          sub_item.ancestors.should == [item["C1"]["C2"], item["C1"], item]
-        end
-      end
-    end # accessing ancestory
-
-
-    describe ".generate_item_id" do
-
-      it "downcases the id" do
-        MenuItem.new(:id => "Identifier").id.should == "identifier"
-      end
-
-      it "should set underscore any spaces" do
-        MenuItem.new(:id => "An Id").id.should == "an_id"
-      end
-
-      it "should return a proc if label was a proc" do
-        MenuItem.new(:label => proc{ "Dynamic" }).id.should be_an_instance_of(Proc)
-      end
-
-    end
-
-  end
-end

data/vendor/deps/active_admin/spec/unit/menu_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'active_admin/menu'
-require 'active_admin/menu_item'
-
-include ActiveAdmin
-
-describe ActiveAdmin::Menu do
-
-  context "with no items" do
-
-    it "should have an empty item collection" do
-      menu = Menu.new
-      menu.items.should be_empty
-    end
-
-    it "should accept new items" do
-      menu = Menu.new
-      menu.add :label => "Dashboard"
-      menu.items.first.label.should == "Dashboard"
-    end
-
-  end
-
-  context "with many item" do
-    let(:menu) do
-      Menu.new do |m|
-        m.add :label => "Dashboard"
-        m.add :label => "Blog"
-      end
-    end
-
-    it "should give access to the menu item as an array" do
-      menu['Dashboard'].label.should == 'Dashboard'
-    end
-  end
-
-  describe "adding items with children" do
-
-    it "should add an empty item if the parent does not exist" do
-      menu = Menu.new
-      menu.add :parent => "Admin", :label  => "Users"
-
-      menu["Admin"]["Users"].should be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-
-    it "should add a child to a parent if it exists" do
-      menu = Menu.new
-      menu.add :parent => "Admin", :label  => "Users"
-      menu.add :parent => "Admin", :label  => "Projects"
-
-      menu["Admin"]["Projects"].should be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-  end
-
-end
-

data/vendor/deps/active_admin/spec/unit/namespace/authorization_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Resource, "authorization" do
-
-  let(:app){ ActiveAdmin::Application.new }
-  let(:namespace){ ActiveAdmin::Namespace.new(app, :admin) }
-  let(:mock_auth){ mock }
-
-  describe "authorization_adapter" do
-
-    it "should return AuthorizationAdapter by default" do
-      namespace.authorization_adapter.should == ActiveAdmin::AuthorizationAdapter
-    end
-
-    it "should be settable on the namespace" do
-      namespace.authorization_adapter.should == ActiveAdmin::AuthorizationAdapter
-      namespace.authorization_adapter = mock_auth
-
-      namespace.authorization_adapter.should == mock_auth
-    end
-
-    it "should be settable on the application" do
-      namespace.authorization_adapter.should == ActiveAdmin::AuthorizationAdapter
-      app.authorization_adapter = mock_auth
-
-      namespace.authorization_adapter.should == mock_auth
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/namespace/register_page_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper' 
-
-describe ActiveAdmin::Namespace, "registering a page" do
-
-  let(:application){ ActiveAdmin::Application.new }
-
-  let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-  let(:menu){ namespace.fetch_menu(:default) }
-
-  context "with no configuration" do
-    before do
-      namespace.register_page "Status"
-    end
-
-    it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Status')
-    end
-
-    it "should create a new controller in the default namespace" do
-      defined?(Admin::StatusController).should be_true
-    end
-
-    it "should create a menu item" do
-      menu["Status"].should be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-  end # context "with no configuration"
-
-  context "with a block configuration" do
-    it "should be evaluated in the dsl" do
-      lambda {
-        namespace.register_page "Status" do
-          raise "Hello World"
-        end
-      }.should raise_error
-    end
-  end # context "with a block configuration"
-
-  describe "adding to the menu" do
-    describe "adding as a top level item" do
-      before do
-        namespace.register_page "Status"
-      end
-
-      it "should add a new menu item" do
-        menu['Status'].should_not be_nil
-      end
-    end # describe "adding as a top level item"
-
-    describe "adding as a child" do
-      before do
-        namespace.register_page "Status" do
-          menu :parent => 'Extra'
-        end
-      end
-      it "should generate the parent menu item" do
-        menu['Extra'].should_not be_nil
-      end
-      it "should generate its own child item" do
-        menu['Extra']['Status'].should_not be_nil
-      end
-    end # describe "adding as a child"
-
-    describe "disabling the menu" do
-      before do
-        namespace.register_page "Status" do
-          menu false
-        end
-      end
-      it "should not create a menu item" do
-        expect {
-          menu["Status"]
-        }.to raise_error(KeyError)
-      end
-    end # describe "disabling the menu"
-    
-    describe "setting menu priority" do
-      before do
-        namespace.register_page "Status" do
-          menu :priority => 2
-        end
-      end
-      it "should have a custom priority of 2" do
-        menu["Status"].priority.should == 2
-      end
-    end # describe "setting menu priority"
-    
-    describe "setting a condition for displaying" do
-      before do
-        namespace.register_page "Status" do
-          menu :if => proc { false }
-        end
-      end
-      it "should have a proc returning false" do
-        menu["Status"].display_if_block.should be_instance_of(Proc)
-        menu["Status"].display_if_block.call.should == false
-      end
-    end # describe "setting a condition for displaying"
-  end # describe "adding to the menu"
-end

data/vendor/deps/active_admin/spec/unit/namespace/register_resource_spec.rb

@@ -1,187 +0,0 @@
-require 'spec_helper' 
-
-describe ActiveAdmin::Namespace, "registering a resource" do
-
-  let(:application){ ActiveAdmin::Application.new }
-
-  let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-  let(:menu){ namespace.fetch_menu(:default) }
-
-  context "with no configuration" do
-    before do
-      namespace.register Category
-    end
-    it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Category')
-    end
-    it "should create a new controller in the default namespace" do
-      defined?(Admin::CategoriesController).should be_true
-    end
-    it "should create the dashboard controller" do
-      defined?(Admin::DashboardController).should be_true
-    end
-    it "should create a menu item" do
-      menu["Categories"].should be_an_instance_of(ActiveAdmin::MenuItem)
-      menu["Categories"].url.should be_an_instance_of(Proc)
-    end
-  end # context "with no configuration"
-
-  context "with a block configuration" do
-    it "should be evaluated in the dsl" do
-      lambda {
-        namespace.register Category do
-          raise "Hello World"
-        end
-      }.should raise_error
-    end
-  end # context "with a block configuration"
-
-  context "with a resource that's namespaced" do
-    before do
-      module ::Mock; class Resource; def self.has_many(arg1, arg2); end; end; end
-      namespace.register Mock::Resource
-    end
-
-    it "should store the namespaced registered configuration" do
-      namespace.resources.keys.should include('Mock::Resource')
-    end
-    it "should create a new controller in the default namespace" do
-      defined?(Admin::MockResourcesController).should be_true
-    end
-    it "should create a menu item" do
-      menu["Mock Resources"].should be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-
-    it "should use the resource as the model in the controller" do
-      Admin::MockResourcesController.resource_class.should == Mock::Resource
-    end
-
-  end # context "with a resource that's namespaced"
-
-  describe "finding resource instances" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should return the resource when its been registered" do
-      post = namespace.register Post
-      namespace.resource_for(Post).should == post
-    end
-
-    it 'should return nil when the resource has not been registered' do
-      namespace.resource_for(Post).should == nil
-    end
-
-    it "should return the parent when the parent class has been registered and the child has not" do
-      user = namespace.register User
-      namespace.resource_for(Publisher).should == user
-    end
-
-    it "should return the resource if it and it's parent were registered" do
-      user = namespace.register User
-      publisher = namespace.register Publisher
-      namespace.resource_for(Publisher).should == publisher
-    end
-
-  end # describe "finding resource instances"
-
-  describe "adding to the menu" do
-    describe "adding as a top level item" do
-      before do
-        namespace.register Category
-      end
-      it "should add a new menu item" do
-        menu['Categories'].should_not be_nil
-      end
-    end # describe "adding as a top level item"
-
-    describe "adding as a child" do
-      before do
-        namespace.register Category do
-          menu :parent => 'Blog'
-        end
-      end
-      it "should generate the parent menu item" do
-        menu['Blog'].should_not be_nil
-      end
-      it "should generate its own child item" do
-        menu['Blog']['Categories'].should_not be_nil
-      end
-    end # describe "adding as a child"
-
-    describe "disabling the menu" do
-      before do
-        namespace.register Category do
-          menu false
-        end
-      end
-      it "should not create a menu item" do
-        expect {
-          menu["Categories"]
-        }.to raise_error(KeyError)
-      end
-    end # describe "disabling the menu"
-    
-    describe "setting menu priority" do
-      before do
-        namespace.register Category do
-          menu :priority => 2
-        end
-      end
-      it "should have a custom priority of 2" do
-        menu["Categories"].priority.should == 2
-      end
-    end # describe "setting menu priority"
-    
-    describe "setting a condition for displaying" do
-      before do
-        namespace.register Category do
-          menu :if => proc { false }
-        end
-      end
-      it "should have a proc returning false" do
-        menu["Categories"].display_if_block.should be_instance_of(Proc)
-        menu["Categories"].display_if_block.call.should == false
-      end
-    end # describe "setting a condition for displaying"
-
-    describe "adding as a belongs to" do
-      context "when not optional" do
-        before do
-          namespace.register Post do
-            belongs_to :author
-          end
-        end
-        it "should not show up in the menu" do
-          expect {
-            menu["Posts"]
-          }.to raise_error(KeyError)
-        end
-      end
-      context "when optional" do
-        before do
-          namespace.register Post do
-            belongs_to :author, :optional => true
-          end
-        end
-        it "should show up in the menu" do
-          menu["Posts"].should_not be_nil
-        end
-      end
-    end
-  end # describe "adding to the menu"
-
-  describe "dashboard controller name" do
-    context "when namespaced" do
-      it "should be namespaced" do
-        namespace = ActiveAdmin::Namespace.new(application, :admin)
-        namespace.dashboard_controller_name.should == "Admin::DashboardController"
-      end
-    end
-    context "when not namespaced" do
-      it "should not be namespaced" do
-        namespace = ActiveAdmin::Namespace.new(application, :root)
-        namespace.dashboard_controller_name.should == "DashboardController"
-      end
-    end
-  end # describe "dashboard controller name"
-end # describe "registering a resource"

data/vendor/deps/active_admin/spec/unit/namespace_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper' 
-
-describe ActiveAdmin::Namespace do
-
-  let(:application){ ActiveAdmin::Application.new }
-
-  context "when new" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should have an application instance" do
-      namespace.application.should == application
-    end
-
-    it "should have a name" do
-      namespace.name.should == :admin
-    end
-
-    it "should have no resources" do
-      namespace.resources.resources.should be_empty
-    end
-
-    it "should not have any menu item" do
-      if ActiveAdmin::Dashboards.built?
-        # DEPRECATED behavior. If a dashboard was built while running this
-        # spec, then an item gets added to the menu
-        namespace.fetch_menu(:default).should have(1).item
-      else
-        namespace.fetch_menu(:default).items.should be_empty
-      end
-    end
-  end # context "when new"
-
-  describe "settings" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should inherit the site title from the application" do
-      ActiveAdmin::Namespace.setting :site_title, "Not the Same"
-      namespace.site_title.should == application.site_title
-    end
-
-    it "should be able to override the site title" do
-      namespace.site_title.should == application.site_title
-      namespace.site_title = "My Site Title"
-      namespace.site_title.should_not == application.site_title
-    end
-  end
-
-
-  describe "#fetch_menu" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "returns the menu" do
-      namespace.fetch_menu(:default).should be_an_instance_of(ActiveAdmin::Menu)
-    end
-
-    it "should have utility nav menu" do
-      namespace.fetch_menu(:utility_navigation).should be_an_instance_of(ActiveAdmin::Menu)
-    end
-
-    it "should raise an exception if the menu doesn't exist" do
-      expect {
-        namespace.fetch_menu(:not_a_menu_that_exists)
-      }.to raise_error(KeyError)
-    end
-  end
-
-  describe "#build_menu" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should set the block as a menu build callback" do
-      namespace.build_menu do |menu|
-        menu.add :label => "menu item"
-      end
-
-      namespace.fetch_menu(:default)["menu item"].should_not be_nil
-    end
-
-    it "should set a block on a custom menu" do
-      namespace.build_menu :test do |menu|
-        menu.add :label => "menu item"
-      end
-
-      namespace.fetch_menu(:test)["menu item"].should_not be_nil
-    end
-  end
-
-  describe "utility navigation" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-    let(:menu) do 
-      namespace.build_menu :utility_navigation do |menu|
-        menu.add :label => "ActiveAdmin.info", :url => "http://www.activeadmin.info", :html_options => { :target => :blank }
-        namespace.add_logout_button_to_menu menu, 1, :class => "matt"
-      end
-      namespace.fetch_menu(:utility_navigation)
-    end
-
-    it "should have a logout button to the far left" do
-      menu["Logout"].should_not be_nil
-      menu["Logout"].priority.should == 1
-    end
-
-    it "should have a static link with a target of :blank" do
-      menu["ActiveAdmin.info"].should_not be_nil
-      menu["ActiveAdmin.info"].html_options.should include(:target => :blank)
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/page_controller_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::PageController do
-  let(:controller) { ActiveAdmin::PageController.new }
-end

data/vendor/deps/active_admin/spec/unit/page_spec.rb

@@ -1,72 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper' 
-require File.expand_path('config_shared_examples', File.dirname(__FILE__))
-
-module ActiveAdmin
-  describe Page do
-
-    it_should_behave_like "ActiveAdmin::Config"
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= namespace.register_page("Chocolate I lØve You!", options)
-    end
-
-    describe "controller name" do
-      it "should return a namespaced controller name" do
-        config.controller_name.should == "Admin::ChocolateILoveYouController"
-      end
-      context "when non namespaced controller" do
-        let(:namespace){ ActiveAdmin::Namespace.new(application, :root) }
-        it "should return a non namespaced controller name" do
-          config.controller_name.should == "ChocolateILoveYouController"
-        end
-      end
-    end
-
-    describe "#resource_name" do
-      it "returns the name" do
-        config.resource_name.should == "Chocolate I lØve You!"
-      end
-
-      it "returns the singular, lowercase name" do
-        config.resource_name.singular.should == "chocolate i lØve you!"
-      end
-    end
-
-    describe "#plural_resource_label" do
-      it "returns the singular name" do
-        config.plural_resource_label.should == "Chocolate I lØve You!"
-      end
-    end
-
-    describe "#underscored_resource_name" do
-      it "returns the resource name underscored" do
-        config.underscored_resource_name.should == "chocolate_i_love_you"
-      end
-    end
-
-    describe "#camelized_resource_name" do
-      it "returns the resource name camel case" do
-        config.camelized_resource_name.should == "ChocolateILoveYou"
-      end
-    end
-
-    it "should not belong_to anything" do
-      config.belongs_to?.should == false
-    end
-
-    it "should not have any action_items" do
-      config.action_items?.should == false
-    end
-
-    it "should not have any sidebar_sections" do
-      config.sidebar_sections?.should == false
-    end
-
-  end
-end