activeadmin_addons 1.4.0 → 1.8.2

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/spec/unit/namespace/authorization_spec.rb

@@ -1,27 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::Resource, "authorization" do
-
-  let(:app){ ActiveAdmin::Application.new }
-  let(:namespace){ ActiveAdmin::Namespace.new(app, :admin) }
-  let(:auth){ double }
-
-  describe "authorization_adapter" do
-
-    it "should return AuthorizationAdapter by default" do
-      expect(app.authorization_adapter).to       eq ActiveAdmin::AuthorizationAdapter
-      expect(namespace.authorization_adapter).to eq ActiveAdmin::AuthorizationAdapter
-    end
-
-    it "should be settable on the namespace" do
-      namespace.authorization_adapter = auth
-      expect(namespace.authorization_adapter).to eq auth
-    end
-
-    it "should be settable on the application" do
-      app.authorization_adapter = auth
-      expect(app.authorization_adapter).to eq auth
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/spec/unit/namespace/register_page_spec.rb

@@ -1,99 +0,0 @@
-require 'rails_helper'
-
-RSpec.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
-      expect(namespace.resources.keys).to include('Status')
-    end
-
-    it "should create a new controller in the default namespace" do
-      expect(defined?(Admin::StatusController)).to eq 'constant'
-    end
-
-    it "should create a menu item" do
-      expect(menu["Status"]).to be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-  end
-
-  context "with a block configuration" do
-    it "should be evaluated in the dsl" do
-      expect{ |block|
-        namespace.register_page "Status", &block
-      }.to yield_control
-    end
-  end
-
-  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
-        expect(menu['Status']).to_not eq nil
-      end
-    end
-
-    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
-        expect(menu['Extra']).to_not eq nil
-      end
-
-      it "should generate its own child item" do
-        expect(menu['Extra']['Status']).to_not eq nil
-      end
-    end
-
-    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 eq nil
-      end
-    end # describe "disabling the menu"
-  end # describe "adding to the menu"
-
-  describe "adding as a belongs to" do
-    context "when not optional" do
-      before do
-        namespace.register_page "Reports" do
-          belongs_to :author
-        end
-      end
-
-      it "should be excluded from the menu" do
-        expect(menu["Reports"]).to be_nil
-      end
-    end
-
-    context "when optional" do
-      before do
-        namespace.register_page "Reports" do
-          belongs_to :author, optional: true
-        end
-      end
-
-      it "should be in the menu" do
-        expect(menu["Reports"]).to_not be_nil
-      end
-    end
-  end # describe "adding as a belongs to"
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/spec/unit/namespace/register_resource_spec.rb

@@ -1,162 +0,0 @@
-require 'rails_helper'
-
-# TODO: refactor this file so it doesn't depend on the Admin namespace in such a broken way.
-#       Specifically, the dashboard is already defined.
-
-RSpec.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) }
-
-  after { namespace.unload! }
-
-  context "with no configuration" do
-    before do
-      namespace.register Category
-    end
-
-    it "should store the namespaced registered configuration" do
-      expect(namespace.resources.keys).to include('Category')
-    end
-
-    it "should create a new controller in the default namespace" do
-      expect(defined?(Admin::CategoriesController)).to eq 'constant'
-    end
-
-    skip "should not create the dashboard controller" do
-      defined?(Admin::DashboardController).to_not eq 'constant'
-    end
-
-    it "should create a menu item" do
-      expect(menu["Categories"]).to be_a ActiveAdmin::MenuItem
-      expect(menu["Categories"].instance_variable_get(:@url)).to be_a Proc
-    end
-  end
-
-  context "with a block configuration" do
-    it "should be evaluated in the dsl" do
-      expect{ |block|
-        namespace.register Category, &block
-      }.to yield_control
-    end
-  end
-
-  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
-      expect(namespace.resources.keys).to include('Mock::Resource')
-    end
-    it "should create a new controller in the default namespace" do
-      expect(defined?(Admin::MockResourcesController)).to eq 'constant'
-    end
-    it "should create a menu item" do
-      expect(menu["Mock Resources"]).to be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-
-    it "should use the resource as the model in the controller" do
-      expect(Admin::MockResourcesController.resource_class).to eq Mock::Resource
-    end
-  end # context "with a resource that's namespaced"
-
-  describe "finding resource instances" do
-    it "should return the resource when its been registered" do
-      post = namespace.register Post
-      expect(namespace.resource_for(Post)).to eq post
-    end
-
-    it 'should return nil when the resource has not been registered' do
-      expect(namespace.resource_for(Post)).to eq nil
-    end
-
-    it "should return the parent when the parent class has been registered and the child has not" do
-      user = namespace.register User
-      expect(namespace.resource_for(Publisher)).to eq user
-    end
-
-    it "should return the resource if it and it's parent were registered" do
-      user = namespace.register User
-      publisher = namespace.register Publisher
-      expect(namespace.resource_for(Publisher)).to eq 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
-        expect(menu['Categories']).to_not eq 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
-        expect(menu['Blog']).to_not eq nil
-      end
-      it "should generate its own child item" do
-        expect(menu['Blog']['Categories']).to_not eq 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 eq nil
-      end
-    end # describe "disabling the menu"
-
-    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 eq nil
-        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
-          expect(menu["Posts"]).to_not eq 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, :one)
-        namespace.register Category
-        expect(defined?(One::CategoriesController)).to eq 'constant'
-      end
-    end
-    context "when not namespaced" do
-      it "should not be namespaced" do
-        namespace = ActiveAdmin::Namespace.new(application, :two)
-        namespace.register Category
-        expect(defined?(Two::CategoriesController)).to eq 'constant'
-      end
-    end
-  end # describe "dashboard controller name"
-end # describe "registering a resource"

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/spec/unit/namespace_spec.rb

@@ -1,126 +0,0 @@
-require 'rails_helper'
-
-RSpec.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
-      expect(namespace.application).to eq application
-    end
-
-    it "should have a name" do
-      expect(namespace.name).to eq :admin
-    end
-
-    it "should have no resources" do
-      expect(namespace.resources).to be_empty
-    end
-
-    it "should not have any menu item" do
-      expect(namespace.fetch_menu(:default).children).to be_empty
-    end
-  end # context "when new"
-
-  describe "#unload!" do
-    context "when controller is only defined without a namespace" do
-      before do
-        # To ensure Admin::PostsController is defined
-        ActiveAdmin.register Post
-
-        # To ensure ::PostsController is defined
-        ActiveAdmin.register Post, namespace: false
-
-        # To prevent unload! from unregistering ::PostsController
-        ActiveAdmin.application.namespaces.instance_variable_get(:@namespaces).delete(:root)
-
-        # To force Admin::PostsController to not be there
-        Admin.send(:remove_const, 'PostsController')
-      end
-
-      it "should not crash" do
-        expect { ActiveAdmin.unload! }.not_to raise_error
-      end
-    end
-  end
-
-  describe "settings" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "should inherit the site title from the application" do
-      ActiveSupport::Deprecation.silence do
-        ActiveAdmin::Namespace.setting :site_title, "Not the Same"
-      end
-      expect(namespace.site_title).to eq application.site_title
-    end
-
-    it "should be able to override the site title" do
-      expect(namespace.site_title).to eq application.site_title
-      namespace.site_title = "My Site Title"
-      expect(namespace.site_title).to_not eq application.site_title
-    end
-  end
-
-  describe "#fetch_menu" do
-    let(:namespace){ ActiveAdmin::Namespace.new(application, :admin) }
-
-    it "returns the menu" do
-      expect(namespace.fetch_menu(:default)).to be_an_instance_of(ActiveAdmin::Menu)
-    end
-
-    it "should have utility nav menu" do
-      expect(namespace.fetch_menu(:utility_navigation)).to 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
-
-      expect(namespace.fetch_menu(:default)["menu item"]).to_not eq nil
-    end
-
-    it "should set a block on a custom menu" do
-      namespace.build_menu :test do |menu|
-        menu.add label: "menu item"
-      end
-
-      expect(namespace.fetch_menu(:test)["menu item"]).to_not eq 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
-      expect(menu["Logout"]).to_not eq nil
-      expect(menu["Logout"].priority).to eq 1
-    end
-
-    it "should have a static link with a target of :blank" do
-      expect(menu["ActiveAdmin.info"]).to_not eq nil
-      expect(menu["ActiveAdmin.info"].html_options).to include(target: :blank)
-    end
-
-  end
-
-end

data/vendor/bundle/ruby/2.2.0/bundler/gems/activeadmin-f71b375325eb/spec/unit/order_clause_spec.rb

@@ -1,81 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe ActiveAdmin::OrderClause do
-  subject { described_class.new(config, clause) }
-
-  let(:application) { ActiveAdmin::Application.new }
-  let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-  let(:config) { ActiveAdmin::Resource.new namespace, Post }
-
-  describe 'id_asc (existing column)' do
-    let(:clause) { 'id_asc' }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq('id') }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('asc') }
-    end
-
-    specify '#to_sql prepends table name' do
-      expect(subject.to_sql).to eq '"posts"."id" asc'
-    end
-  end
-
-  describe 'virtual_column_asc' do
-    let(:clause) { 'virtual_column_asc' }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq('virtual_column') }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('asc') }
-    end
-
-    specify '#to_sql' do
-      expect(subject.to_sql).to eq '"virtual_column" asc'
-    end
-  end
-
-  describe "hstore_col->'field'_desc" do
-    let(:clause) { "hstore_col->'field'_desc" }
-
-    it { is_expected.to be_valid }
-
-    describe '#field' do
-      subject { super().field }
-      it { is_expected.to eq("hstore_col->'field'") }
-    end
-
-    describe '#order' do
-      subject { super().order }
-      it { is_expected.to eq('desc') }
-    end
-
-    it 'converts to sql' do
-      expect(subject.to_sql).to eq %Q("hstore_col"->'field' desc)
-    end
-  end
-
-  describe '_asc' do
-    let(:clause) { '_asc' }
-
-    it { is_expected.not_to be_valid }
-  end
-
-  describe 'nil' do
-    let(:clause) { nil }
-
-    it { is_expected.not_to be_valid }
-  end
-end