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

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-
-module MockModuleToInclude
-  def self.included(dsl)
-  end
-end
-
-describe ActiveAdmin::DSL do
-
-  let(:config){ mock }
-  let(:application) { ActiveAdmin::Application.new }
-  let(:namespace) { ActiveAdmin::Namespace.new application, :admin }
-  let(:resource_config) { ActiveAdmin::Resource.new namespace, Post }
-  let(:dsl){ ActiveAdmin::DSL.new(config) }
-
-  describe "#include" do
-
-    it "should call the included class method on the module that is included" do
-      MockModuleToInclude.should_receive(:included).with(dsl)
-      dsl.run_registration_block do
-        include MockModuleToInclude
-      end
-    end
-
-  end
-
-  describe "#menu" do
-
-    it "should set the menu_item_options on the configuration" do
-      config.should_receive(:menu_item_options=).with({:parent => "Admin"})
-      dsl.run_registration_block do
-        menu :parent => "Admin"
-      end
-    end
-
-  end
-
-  describe "#navigation_menu" do
-
-    it "should set the navigation_menu_name on the configuration" do
-      config.should_receive(:navigation_menu_name=).with(:admin)
-      dsl.run_registration_block do
-        navigation_menu :admin
-      end
-    end
-
-    it "should accept a block" do
-
-      dsl = ActiveAdmin::DSL.new(resource_config)
-      dsl.run_registration_block do
-        navigation_menu { :dynamic_menu }
-      end
-
-      resource_config.navigation_menu_name.should == :dynamic_menu
-
-    end
-
-  end
-
-end

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

@@ -1,47 +0,0 @@
-require 'spec_helper'
-require 'active_admin/event'
-
-describe ActiveAdmin::EventDispatcher do
-
-  let(:test_event){ 'active_admin.test_event' }
-  let(:dispatcher){ ActiveAdmin::EventDispatcher.new }
-
-  it "should add a subscriber for an event" do
-    dispatcher.subscribers(test_event).size.should == 0
-    dispatcher.subscribe(test_event){ true }
-    dispatcher.subscribers(test_event).size.should == 1
-  end
-
-  it "should add a subscriber for multiple events" do
-    dispatcher.subscribe(test_event, test_event + "1"){ true }
-    dispatcher.subscribers(test_event).size.should == 1
-    dispatcher.subscribers(test_event + "1").size.should == 1
-  end
-
-  it "should call the dispatch block with no arguments" do
-    dispatcher.subscribe(test_event){ raise StandardError, "From Event Handler" }
-    lambda {
-      dispatcher.dispatch(test_event)
-    }.should raise_error(StandardError, "From Event Handler")
-  end
-
-  it "should call the dispatch block with one argument" do
-    arg = nil
-    dispatcher.subscribe(test_event){|passed_in| arg = passed_in }
-    dispatcher.dispatch(test_event, "My Arg")
-    arg.should == "My Arg"
-  end
-
-  it "should clear all subscribers" do
-    dispatcher.subscribe(test_event){ false }
-    dispatcher.subscribe(test_event + "_2"){ false }
-    dispatcher.clear_all_subscribers!
-    dispatcher.subscribers(test_event).size.should == 0
-    dispatcher.subscribers(test_event + "_2").size.should == 0
-  end
-
-  it "should have a dispatcher available from ActiveAdmin::Event" do
-    ActiveAdmin::Event.should be_an_instance_of(ActiveAdmin::EventDispatcher)
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/filters/filter_form_builder_spec.rb

@@ -1,281 +0,0 @@
-require 'spec_helper' 
-
-
-describe ActiveAdmin::Filters::ViewHelper do
-
-  # Setup an ActionView::Base object which can be used for
-  # generating the form for.
-  let(:helpers) do 
-    view = action_view
-    def view.collection_path
-      "/posts"
-    end
-
-    def view.protect_against_forgery?
-      false
-    end
-
-    def view.a_helper_method
-      "A Helper Method"
-    end
-
-    view
-  end
-
-  def render_filter(search, filters)
-    render_arbre_component({:filter_args => [search, filters]}, helpers) do
-      text_node active_admin_filters_form_for(*assigns[:filter_args])
-    end
-  end
-
-  def filter(name, options = {})
-    render_filter Post.search, @filters.push(options.merge(:attribute => name))
-  end
-
-  before(:each) { @filters = [] }
-
-
-  describe "the form in general" do
-    let(:body) { filter :title }
-
-    it "should generate a form which submits via get" do
-      body.should have_tag("form", :attributes => { :method => 'get', :class => 'filter_form' })
-    end
-
-    it "should generate a filter button" do
-      body.should have_tag("input", :attributes => { :type => "submit",
-                                                        :value => "Filter" })
-    end
-
-    it "should only generate the form once" do
-      body.to_s.scan(/q\[title_contains\]/).size.should == 1
-    end
-
-    it "should generate a clear filters link" do
-      body.should have_tag("a", "Clear Filters", :attributes => { :class => "clear_filters_btn" })
-    end
-  end
-
-  describe "string attribute" do
-    let(:body) { filter :title }
-
-    it "should generate a search field for a string attribute" do
-      body.should have_tag("input", :attributes => { :name => "q[title_contains]"})
-    end
-
-    it "should label a text field with search" do
-      body.should have_tag('label', 'Search Title')
-    end
-
-    it "should translate the label for text field" do
-      begin
-        I18n.backend.store_translations(:en, :activerecord => { :attributes => { :post => { :title => "Name" } } })
-        body.should have_tag('label', 'Search Name')
-      ensure
-        I18n.backend.reload!
-      end
-    end
-
-    context "using starts_with and as" do
-      let(:body) { filter :title_starts_with, :as => :string }
-
-      it "should generate a search field for a string attribute with query starts_with" do
-        body.should have_tag("input", :attributes => { :name => "q[title_starts_with]" })
-      end
-    end
-
-    context "using ends_with and as" do
-      let(:body) { filter :title_ends_with, :as => :string }
-
-      it "should generate a search field for a string attribute with query starts_with" do
-        body.should have_tag("input", :attributes => { :name => "q[title_ends_with]" })
-      end
-    end
-  end
-
-  describe "text attribute" do
-    let(:body) { filter :body }
-
-    it "should generate a search field for a text attribute" do
-      body.should have_tag("input", :attributes => { :name => "q[body_contains]"})
-    end
-
-    it "should label a text field with search" do
-      body.should have_tag('label', 'Search Body')
-    end
-  end
-
-  describe "datetime attribute" do
-    let(:body) { filter :created_at }
-
-    it "should generate a date greater than" do
-      body.should have_tag("input", :attributes => { :name => "q[created_at_gte]", :class => "datepicker"})
-    end
-    it "should generate a seperator" do
-      body.should have_tag("span", :attributes => { :class => "seperator"})
-    end
-    it "should generate a date less than" do
-      body.should have_tag("input", :attributes => { :name => "q[created_at_lte]", :class => "datepicker"})
-    end
-  end
-
-  describe "integer attribute" do
-    let(:body) { filter :id }
-
-    it "should generate a select option for equal to" do
-      body.should have_tag("option", "Equal To", :attributes => { :value => 'id_eq' })
-    end
-    it "should generate a select option for greater than" do
-      body.should have_tag("option", "Greater Than")
-    end
-    it "should generate a select option for less than" do
-      body.should have_tag("option", "Less Than")
-    end
-    it "should generate a text field for input" do
-      body.should have_tag("input", :attributes => {
-                                          :name => /q\[(id_eq|id_equals)\]/ })
-    end
-    it "should select the option which is currently being filtered"
-  end
-
-  describe "boolean attribute" do
-    context "boolean datatypes" do
-      let(:body) { filter :starred }
-
-      it "should create a check box for equals to" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[starred_eq]",
-                                            :type => "checkbox" })
-      end
-    end
-
-    context "non-boolean data types" do
-      let(:body) { filter :title_is_present, :as => :boolean }
-
-      it "should create a check box for equals to" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[title_is_present]",
-                                            :type => "checkbox" })
-      end
-    end
-  end
-
-  describe "belong to" do
-    before do
-      @john = User.create :first_name => "John", :last_name => "Doe", :username => "john_doe"
-      @jane = User.create :first_name => "Jane", :last_name => "Doe", :username => "jane_doe"
-    end
-
-    context "when given as the _id attribute name" do
-      let(:body) { filter :author_id }
-
-      it "should not render as an integer" do
-        body.should_not have_tag("input", :attributes => {
-                                                :name => "q[author_id_eq]"})
-      end
-      it "should render as belongs to select" do
-        body.should have_tag("select", :attributes => {
-                                            :name => "q[author_id_eq]"})
-        body.should have_tag("option", "john_doe", :attributes => {
-                                                           :value => @john.id })
-        body.should have_tag("option", "jane_doe", :attributes => {
-                                                          :value => @jane.id })
-      end
-    end
-
-    context "when given as the name of the relationship" do
-      let(:body) { filter :author }
-
-      it "should generate a select" do
-        body.should have_tag("select", :attributes => {
-                                            :name => "q[author_id_eq]"})
-      end
-      it "should set the default text to 'Any'" do
-        body.should have_tag("option", "Any", :attributes => {
-                                                    :value => "" })
-      end
-      it "should create an option for each related object" do
-        body.should have_tag("option", "john_doe", :attributes => {
-                                                          :value => @john.id })
-        body.should have_tag("option", "jane_doe", :attributes => {
-                                                          :value => @jane.id })
-      end
-
-      context "with a proc" do
-        let :body do
-          filter :title, :as => :select, :collection => proc{ ['Title One', 'Title Two'] }
-        end
-
-        it "should use call the proc as the collection" do
-          body.should have_tag("option", "Title One")
-          body.should have_tag("option", "Title Two")
-        end
-
-        it "should render the collection in the context of the view" do
-          body = filter(:title, :as => :select, :collection => proc{[a_helper_method]})
-          body.should have_tag("option", "A Helper Method")
-        end
-      end
-    end
-
-    context "as check boxes" do
-      let(:body) { filter :author, :as => :check_boxes }
-
-      it "should create a check box for each related object" do
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[author_id_in][]",
-                                            :type => "checkbox",
-                                            :value => @john.id })
-        body.should have_tag("input", :attributes => {
-                                            :name => "q[author_id_in][]",
-                                            :type => "checkbox",          
-                                            :value => @jane.id })
-      end
-    end
-
-    context "when polymorphic relationship" do
-      let(:body) do
-        search = ActiveAdmin::Comment.search
-        render_filter(search, [{:attribute => :resource}])
-      end
-      it "should not generate any field" do
-        body.should have_tag("form", :attributes => { :method => 'get' })
-      end
-    end
-  end # belongs to
-
-
-  describe "conditional display" do
-
-    context "with :if block" do
-      let(:body) do
-        filter :body,   :if => proc{true}
-        filter :author, :if => proc{false}
-      end
-
-      it "should be displayed if true" do
-        body.should have_tag("input", :attributes => { :name => "q[body_contains]"})
-      end
-
-      it "should NOT be displayed if false" do
-        body.should_not have_tag("input", :attributes => { :name => "q[author_id_eq]"})
-      end
-    end
-
-    context "with :unless block" do
-      let(:body) do
-        filter :created_at, :unless => proc{false}
-        filter :updated_at, :unless => proc{true}
-      end
-
-      it "should be displayed if false" do
-        body.should have_tag("input", :attributes => { :name => "q[created_at_gte]"})
-      end
-
-      it "should NOT be displayed if true" do
-        body.should_not have_tag("input", :attributes => { :name => "q[updated_at_gte]"})
-      end
-    end
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/filters/resource_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Filters::ResourceExtension do
-
-  let(:resource) do
-    namespace = ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :admin)
-    namespace.register(Post)
-  end
-
-  it "should return the defaults if no filters are set" do
-    resource.filters.map{|f| f[:attribute].to_s }.sort.should == %w{
-      author body category created_at published_at starred title updated_at
-    }
-  end
-
-  it "should not have defaults when filters are disabled on the resource" do
-    resource.filters = false
-    resource.filters.should be_empty
-  end
-
-  it "should not have defaults when the filters are disabled on the namespace" do
-    resource.namespace.filters = false
-    resource.filters.should be_empty
-  end
-
-  it "should not have defaults when the filters are disabled on the application" do
-    resource.namespace.application.filters = false
-    resource.filters.should be_empty
-  end
-
-  it "should remove a filter" do
-    resource.filters.should include({:attribute => :author})
-    resource.remove_filter :author
-    resource.filters.should_not include({:attribute => :author})
-  end
-
-  it "should add a filter" do
-    resource.add_filter :title
-    resource.filters.should == [{:attribute => :title}]
-  end
-
-  it "should add a filter with options" do
-    resource.add_filter :title, :as => :string
-    resource.filters.should == [{:attribute => :title, :as => :string}]
-  end
-
-  it "should preserve default filters" do
-    resource.preserve_default_filters!
-    resource.add_filter :count, :as => :string
-    resource.filters.map{|f| f[:attribute].to_s }.sort.should == %w{
-      author body category count created_at published_at starred title updated_at
-    }
-  end
-
-  it "should raise an exception if trying to add a filter when they are disabled" do
-    resource.filters = false
-    expect {
-      resource.add_filter :title
-    }.should raise_error(RuntimeError)
-  end
-
-  it "should reset filters" do
-    resource.add_filter :title
-    resource.filters.size.should == 1
-    resource.reset_filters!
-    resource.filters.size.should > 1
-  end
-
-  it "should add a sidebar section for the filters" do
-    resource.sidebar_sections.first.name.should == :filters
-  end
-
-
-end