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

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

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-describe "#pretty_format" do
-  include ActiveAdmin::ViewHelpers::DisplayHelper
-
-  context "when a String is passed in" do
-    it "should return the String passed in" do
-      pretty_format("hello").should == "hello"
-    end
-  end
-
-  context "when a Date or a Time is passed in" do
-    it "should return a localized Date or Time with long format" do
-      t = Time.now
-      self.should_receive(:localize).with(t, {:format => :long}) { "Just Now!" }
-      pretty_format(t).should == "Just Now!"
-    end
-  end
-
-  context "when an ActiveRecord object is passed in" do
-    it "should delegate to auto_link" do
-      post = Post.new
-      self.should_receive(:auto_link).with(post) { "model name" }
-      pretty_format(post).should == "model name"
-    end
-  end
-
-  context "when something else is passed in" do
-    it "should delegate to display_name" do
-      something = Class.new.new
-      self.should_receive(:display_name).with(something) { "I'm not famous" }
-      pretty_format(something).should == "I'm not famous"
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin do
-
-  describe "use_asset_pipeline?" do
-
-    before(:each) do
-      @orig_rails_version = Rails::VERSION::MINOR
-    end
-
-    after(:each) do
-      silence_warnings { Rails::VERSION::MINOR = @orig_rails_version }
-    end
-
-    it "should be false when using rails 3.0.x" do
-      silence_warnings { Rails::VERSION::MINOR = 0 }
-      ActiveAdmin.use_asset_pipeline?.should be_false
-    end
-
-    context "when rails 3.1.x" do
-      before(:each) do
-        @orig_rails_app = Rails.application.dup
-        silence_warnings { Rails::VERSION::MINOR = 1 }
-      end
-
-      after(:each) do
-        Rails.application = @orig_rails_app
-      end
-
-      it "should be false without asset pipeline enabled" do
-        assets = mock(:enabled => false)
-        Rails.application.config.stub!(:assets => assets)
-        ActiveAdmin.use_asset_pipeline?.should be_false
-      end
-
-      it "should be true with asset pipeline enabled" do
-        assets = mock(:enabled => true)
-        Rails.application.config.stub!(:assets => assets)
-        ActiveAdmin.use_asset_pipeline?.should be_true
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-# Ensure we have both constants to play with
-begin
-  ActionDispatch::Reloader
-rescue
-  module ActionDispatch; module Reloader; def self.to_prepare; end; end; end
-end
-
-begin
-  ActionDispatch::Callbacks
-rescue
-  module ActionDispatch; module Callbacks; def self.to_prepare; end; end; end
-end
-
-major_rails_version = Rails.version[0..2]
-
-
-describe ActiveAdmin::Reloader do
-
-  let(:rails_app){ mock(:reload_routes! => true)}
-  let(:mock_app){ mock(:load_paths => ["app/admin"], :unload! => true)}
-  let(:reloader){ ActiveAdmin::Reloader.build(rails_app, mock_app, rails_version) }
-
-  context "when Rails version < 3.2" do
-    let(:rails_version){ TRAVIS_RAILS_VERSIONS.grep(/3.1/).first }
-
-    describe "initialization" do
-
-      it "should initialize a new file update checker" do
-        ActiveSupport::FileUpdateChecker.should_receive(:new).with(mock_app.load_paths).and_return(mock(:execute_if_updated => true))
-        ActiveAdmin::Reloader.build(rails_app, mock_app, TRAVIS_RAILS_VERSIONS.grep(/3.1/).first)
-      end
-
-      it "should build a RailsLessThan31Reloader" do
-        reloader.class.should == ActiveAdmin::Reloader::RailsLessThan31Reloader
-      end
-
-    end
-
-    describe "#reloader_class" do
-
-      it "should use ActionDispatch::Reloader if rails 3.1" do
-        reloader = ActiveAdmin::Reloader.build rails_app, mock_app, TRAVIS_RAILS_VERSIONS.grep(/3.1/).first
-        reloader.reloader_class.should == ActionDispatch::Reloader
-      end
-
-      it "should use ActionDispatch::Callbacks if rails 3.0" do
-        reloader = ActiveAdmin::Reloader.build rails_app, mock_app, TRAVIS_RAILS_VERSIONS.grep(/3.0/).first
-        reloader.reloader_class.should == ActionDispatch::Callbacks
-      end
-
-    end
-
-    describe "#reload!" do
-
-      it "should unload the active admin app" do
-        mock_app.should_receive(:unload!)
-        reloader.reload!
-      end
-
-      it "should reload the rails app routes" do
-        rails_app.should_receive(:reload_routes!)
-        reloader.reload!
-      end
-
-      it 'should reset the files within the file_update_checker' do
-        reloader.file_update_checker.paths.should_receive(:clear)
-        reloader.file_update_checker.paths.should_receive(:<<).with("app/admin")
-        reloader.reload!
-      end
-
-    end
-
-    describe "#watched_paths" do
-      let(:mock_app){ ActiveAdmin::Application.new }
-      let(:admin_path){ File.join(Rails.root, "app", "admin") }
-
-      before do
-        mock_app.load_paths = [admin_path]
-      end
-
-      it "should return the load path directories" do
-        reloader.watched_paths.should include(admin_path)
-      end
-
-      it "should include all files in the directory" do
-        root = Rails.root + "/app/admin"
-        reloader.watched_paths.should include(*Dir["#{admin_path}/**/*.rb"])
-      end
-
-    end
-
-  end
-
-  context "when Rails >= 3.2" do
-    let(:rails_version){ TRAVIS_RAILS_VERSIONS.grep(/3.2/).first }
-
-    describe "initialization" do
-
-      it "should build a Rails32Reloader" do
-        reloader.class.should == ActiveAdmin::Reloader::Rails32Reloader
-      end
-
-    end
-
-    describe "attach!" do
-      before do
-        mock_app.load_paths << "app/active_admin"
-        ActionDispatch::Reloader.stub!(:to_prepare => true)
-      end
-
-      it "should the load paths to the watchable_dirs" do
-        config = mock(:watchable_dirs => {})
-        rails_app.should_receive(:config).twice.and_return(config)
-        reloader.attach!
-
-        config.watchable_dirs["app/admin"].should == [:rb]
-        config.watchable_dirs["app/active_admin"].should == [:rb]
-      end
-    end
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/resource/action_items_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Resource::ActionItems do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.register(Post)
-  end
-
-  describe "adding a new action item" do
-
-    before do
-      resource.clear_action_items!
-      resource.add_action_item do
-        # Empty ...
-      end
-    end
-
-    it "should add an action item" do
-      resource.action_items.size.should == 1
-    end
-
-    it "should store an instance of ActionItem" do
-      resource.action_items.first.should be_an_instance_of(ActiveAdmin::ActionItem)
-    end
-
-    it "should store the block in the action item" do
-      resource.action_items.first.block.should_not be_nil
-    end
-
-  end
-
-  describe "setting an action item to only display on specific controller actions" do
-
-    before do
-      resource.clear_action_items!
-      resource.add_action_item :only => :index do
-        raise StandardError
-      end
-      resource.add_action_item :only => :show do
-        # Empty ...
-      end
-    end
-
-    it "should return only relevant action items" do
-      resource.action_items_for(:index).size.should == 1
-      lambda {
-        resource.action_items_for(:index).first.call
-      }.should raise_exception(StandardError)
-    end
-
-  end
-
-  describe "default action items" do
-
-    it "should have 3 action items" do
-      resource.action_items.size.should == 3
-    end
-
-  end
-
-end

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

@@ -1,18 +0,0 @@
-require 'spec_helper' 
-
-module ActiveAdmin
-  describe Resource, "Menu" do
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    # TODO...
-
-  end
-end

data/vendor/deps/active_admin/spec/unit/resource/naming_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-module ActiveAdmin
-  describe Resource, "Naming" do
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    module ::Mock class Resource < ActiveRecord::Base; end; end
-    module NoActiveModel class Resource; end; end
-
-    describe "singular resource name" do
-      context "when class" do
-        it "should be the underscored singular resource name" do
-          config.resource_name.singular.should == "category"
-        end
-      end
-      context "when a class in a module" do
-        it "should underscore the module and the class" do
-          Resource.new(namespace, Mock::Resource).resource_name.singular.should == "mock_resource"
-        end
-      end
-      context "when you pass the 'as' option" do
-        it "should underscore the passed through string" do
-          config(:as => "Blog Category").resource_name.singular.should == "blog_category"
-        end
-      end
-    end
-
-    describe "resource label" do
-      it "should return a pretty name" do
-        config.resource_label.should == "Category"
-      end
-
-      it "should return the plural version" do
-        config.plural_resource_label.should == "Categories"
-      end
-
-      context "when the :as option is given" do
-        it "should return the custom name" do
-          config(:as => "My Category").resource_label.should == "My Category"
-        end
-      end
-
-      context "when a class in a module" do
-        it "should include the module and the class" do
-          Resource.new(namespace, Mock::Resource).resource_label.should == "Mock Resource"
-        end
-
-        it "should include the module and the pluralized class" do
-          Resource.new(namespace, Mock::Resource).plural_resource_label.should == "Mock Resources"
-        end
-      end
-
-      describe "I18n integration" do
-        describe "singular label" do
-          it "should return the titleized model_name.human" do
-            config.resource_name.should_receive(:human).and_return "Da category"
-
-            config.resource_label.should == "Da category"
-          end
-        end
-
-        describe "plural label" do
-          it "should return the titleized plural version defined by i18n if available" do
-            I18n.should_receive(:translate).at_least(:once).and_return("Da categories")
-            config.plural_resource_label.should == "Da categories"
-          end
-        end
-
-      end
-    end
-
-  end
-end

data/vendor/deps/active_admin/spec/unit/resource/page_presenters_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Resource::PagePresenters do
-
-  let(:namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin) }
-  let(:resource){ namespace.register(Post) }
-
-  it "should have an empty set of configs on initialize" do
-    resource.page_presenters.should == {}
-  end
-
-  it "should add a page presenter" do
-    page_presenter = ActiveAdmin::PagePresenter.new
-    resource.set_page_presenter(:index, page_presenter)
-    resource.page_presenters[:index].should == page_presenter
-  end
-
-  describe "#get_page_presenter" do
-
-    it "should return a page config when set" do
-      page_presenter = ActiveAdmin::PagePresenter.new
-      resource.set_page_presenter(:index, page_presenter)
-      resource.get_page_presenter(:index).should == page_presenter
-    end
-
-    it "should return nil when no page config set" do
-      resource.get_page_presenter(:index).should == nil
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/resource/pagination_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper' 
-
-module ActiveAdmin
-  describe Resource, "Pagination" do
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    describe "#paginate" do
-      it "should default to true" do
-        config.paginate.should == true
-      end
-
-      it "should be settable to false" do
-        config.paginate = false
-        config.paginate.should == false
-      end
-    end
-
-    describe "#per_page" do
-      it "should default to namespace.default_per_page" do
-        namespace.should_receive(:default_per_page).and_return(5)
-        config.per_page.should == 5
-      end
-      
-      it "should be settable" do
-        config.per_page = 5
-        config.per_page.should == 5
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/resource/scopes_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper' 
-
-module ActiveAdmin
-  describe Resource, "Scopes" do
-
-    before { load_defaults! }
-
-    let(:application){ ActiveAdmin::Application.new }
-    let(:namespace){ Namespace.new(application, :admin) }
-
-    def config(options = {})
-      @config ||= Resource.new(namespace, Category, options)
-    end
-
-    describe "adding a scope" do
-
-      it "should add a scope" do
-        config.scope :published
-        config.scopes.first.should be_a(ActiveAdmin::Scope)
-        config.scopes.first.name.should == "Published"
-      end
-
-      it "should retrive a scope by its id" do
-        config.scope :published
-        config.get_scope_by_id(:published).name.should == "Published"
-      end
-
-      it "should not add a scope with the same name twice" do
-        config.scope :published
-        config.scope :published
-        config.scopes.size.should == 1
-      end
-
-      it "should update a scope with the same id" do
-        config.scope :published
-        config.scopes.first.scope_block.should be_nil
-        config.scope(:published){  }
-        config.scopes.first.scope_block.should_not be_nil
-      end
-
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/resource/sidebars_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Resource::Sidebars do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.register(Post)
-  end
-
-  let(:sidebar) { ActiveAdmin::SidebarSection.new(:help) }
-
-  describe "adding a new sidebar section" do
-
-    before do
-      resource.clear_sidebar_sections!
-      resource.sidebar_sections << sidebar
-    end
-
-    it "should add a sidebar section" do
-      resource.should have(1).sidebar_sections
-    end
-
-  end
-
-  describe "retrieving sections for a controller action" do
-
-    let(:only_index){ ActiveAdmin::SidebarSection.new(:help, :only => :index) }
-    let(:only_show){ ActiveAdmin::SidebarSection.new(:help, :only => :show) }
-
-    before do
-      resource.clear_sidebar_sections!
-      resource.sidebar_sections << only_index
-      resource.sidebar_sections << only_show
-    end
-
-    it "should only return the relevant action items" do
-      resource.should have(2).sidebar_sections
-      resource.sidebar_sections_for("index").should == [only_index]
-    end
-
-  end
-
-end

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

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require 'active_admin/resource_collection'
-
-include ActiveAdmin
-
-describe ActiveAdmin::ResourceCollection do
-
-  let(:collection){ ResourceCollection.new }
-
-  it "should have no resources when new" do
-    collection.resources.should == []
-  end
-
-  it "should be enumerable" do
-    resource = mock(:resource_name => "MyResource")
-    collection.add(resource)
-    collection.each{|r| r.should == resource }
-  end
-
-  it "should return the available keys" do
-    resource = mock(:resource_name => "MyResource")
-    collection.add resource
-    collection.keys.should == [resource.resource_name]
-  end
-
-  describe "adding a new resource" do
-    let(:resource){ mock(:resource_name => "MyResource") }
-
-    it "should return the resource" do
-      collection.add(resource).should == resource
-    end
-
-    it "should add a new resource" do
-      collection.add(resource)
-      collection.resources.should == [resource]
-    end
-
-    it "should be available by name" do
-      collection.add(resource)
-      collection.find_by_key(resource.resource_name).should == resource
-    end
-  end
-
-  describe "adding a new resource when the key already exists" do
-    let(:stored_resource){ mock(:resource_name => "MyResource") }
-    let(:resource){ mock(:resource_name => "MyResource") }
-
-    before do
-      collection.add(stored_resource)
-    end
-
-    it "should return the original resource" do
-      collection.add(resource).should == stored_resource
-    end
-
-    it "should not add a new resource" do
-      collection.add(resource)
-      collection.resources.should == [stored_resource]
-    end
-  end
-
-  describe "adding an existing resource key with a different resource class" do
-    let(:stored_resource){ mock(:resource_name => "MyResource", :resource_class => mock) }
-    let(:resource){ mock(:resource_name => "MyResource", :resource_class => mock) }
-
-    it "should raise a ActiveAdmin::ResourceMismatchError" do
-      collection.add(stored_resource)
-      lambda {
-        collection.add(resource)
-      }.should raise_error(ActiveAdmin::ResourceMismatchError)
-    end
-
-  end
-
-  describe "#find_by_resource_class" do
-
-    let(:base_class){ mock(:to_s => "BaseClass")}
-    let(:resource_from_base_class){ mock(:resource_name => "MyBaseClassResource", :resource_class => base_class )}
-    let(:resource_class){ mock(:base_class => base_class, :to_s => "ResourceClass") }
-    let(:resource){ mock(:resource_name => "MyResource", :resource_class => resource_class) }
-
-    it "should find a resource when it's in the collection" do
-      collection.add resource
-      collection.find_by_resource_class(resource_class).should == resource
-    end
-
-    it "should return nil when the resource class is not in the collection" do
-      collection.find_by_resource_class(resource_class).should == nil
-    end
-
-    it "should return the resource when it and it's base class is in the collection" do
-      collection.add resource_from_base_class
-      collection.find_by_resource_class(resource_class).should == resource_from_base_class
-    end
-
-    it "should return nil the resource_class does not repond to base_class and it's not in the collection" do
-      collection.find_by_resource_class(mock).should == nil
-    end
-  end
-
-end