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

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

@@ -1,426 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::FormBuilder do
-
-  # Setup an ActionView::Base object which can be used for
-  # generating the form for.
-  let(:helpers) do
-    view = action_view
-    def view.posts_path
-      "/posts"
-    end
-
-    def view.protect_against_forgery?
-      false
-    end
-
-    def view.url_for(*args)
-      if args.first == {:action => "index"}
-        posts_path
-      else
-        super
-      end
-    end
-
-    def view.a_helper_method
-      "A Helper Method"
-    end
-
-    view
-  end
-
-  def build_form(options = {}, form_object = Post.new, &block)
-    options = {:url => helpers.posts_path}.merge(options)
-
-    render_arbre_component({:form_object => form_object, :form_options => options, :form_block => block}, helpers)do
-      text_node active_admin_form_for(assigns[:form_object], assigns[:form_options], &assigns[:form_block])
-    end.to_s
-  end
-
-  context "in general with actions" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :title
-          f.input :body
-        end
-        f.actions do
-          f.action :submit, :label => "Submit Me"
-          f.action :submit, :label => "Another Button"
-        end
-      end
-    end
-
-   it "should generate a text input" do
-      body.should have_tag("input", :attributes => { :type => "text",
-                                                     :name => "post[title]" })
-    end
-    it "should generate a textarea" do
-      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
-    end
-    it "should only generate the form once" do
-      body.scan(/Title/).size.should == 1
-    end
-    it "should generate actions" do
-      body.should have_tag("input", :attributes => {  :type => "submit",
-                                                          :value => "Submit Me" })
-      body.should have_tag("input", :attributes => {  :type => "submit",
-                                                          :value => "Another Button" })
-    end
-  end
-
-  context "in general with actions" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :title
-          f.input :body
-        end
-        f.actions do
-          f.action :submit, :button_html => { :value => "Submit Me" }
-          f.action :submit, :button_html => { :value => "Another Button" }
-        end
-      end
-    end
-
-    it "should generate a text input" do
-      body.should have_tag("input", :attributes => { :type => "text",
-                                                     :name => "post[title]" })
-    end
-    it "should generate a textarea" do
-      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
-    end
-    it "should only generate the form once" do
-      body.scan(/Title/).size.should == 1
-    end
-    it "should generate actions" do
-      body.should have_tag("input", :attributes => {  :type => "submit",
-                                                          :value => "Submit Me" })
-      body.should have_tag("input", :attributes => {  :type => "submit",
-                                                          :value => "Another Button" })
-    end
-  end
-
-  context "when polymorphic relationship" do
-    it "should raise error" do
-      lambda {
-        comment = ActiveAdmin::Comment.new
-        build_form({:url => "admins/comments"}, comment) do |f|
-          f.inputs :resource
-        end
-      }.should raise_error(Formtastic::PolymorphicInputWithoutCollectionError)
-    end
-  end
-
-  describe "passing in options with actions" do
-    let :body do
-      build_form :html => { :multipart => true } do |f|
-        f.inputs :title
-        f.actions
-      end
-    end
-    it "should pass the options on to the form" do
-      body.should have_tag("form", :attributes => { :enctype => "multipart/form-data" })
-    end
-  end
-
-  describe "passing in options with actions" do
-    let :body do
-      build_form :html => { :multipart => true } do |f|
-        f.inputs :title
-        f.actions
-      end
-    end
-    it "should pass the options on to the form" do
-      body.should have_tag("form", :attributes => { :enctype => "multipart/form-data" })
-    end
-  end
-
-
-  context "with actions" do
-    it "should generate the form once" do
-      body = build_form do |f|
-        f.inputs do
-          f.input :title
-        end
-        f.actions
-      end
-      body.scan(/id=\"post_title\"/).size.should == 1
-    end
-    it "should generate one button and a cancel link" do
-      body = build_form do |f|
-        f.actions
-      end
-      body.scan(/type=\"submit\"/).size.should == 1
-      body.scan(/class=\"cancel\"/).size.should == 1
-    end
-    it "should generate multiple actions" do
-      body = build_form do |f|
-        f.actions do
-          f.action :submit, :label => "Create & Continue"
-          f.action :submit, :label => "Create & Edit"
-        end
-      end
-      body.scan(/type=\"submit\"/).size.should == 2
-      body.scan(/class=\"cancel\"/).size.should == 0
-    end
-
-  end
-
-  context "with actons" do
-    it "should generate the form once" do
-      body = build_form do |f|
-        f.inputs do
-          f.input :title
-        end
-        f.actions
-      end
-      body.scan(/id=\"post_title\"/).size.should == 1
-    end
-    it "should generate one button and a cancel link" do
-      body = build_form do |f|
-        f.actions
-      end
-      body.scan(/type=\"submit\"/).size.should == 1
-      body.scan(/class=\"cancel\"/).size.should == 1
-    end
-    it "should generate multiple actions" do
-      body = build_form do |f|
-        f.actions do
-          f.action :submit, :label => "Create & Continue"
-          f.action :submit, :label => "Create & Edit"
-        end
-      end
-      body.scan(/type=\"submit\"/).size.should == 2
-      body.scan(/class=\"cancel\"/).size.should == 0
-    end
-  end
-
-  context "without passing a block to inputs" do
-    let :body do
-      build_form do |f|
-        f.inputs :title, :body
-      end
-    end
-    it "should have a title input" do
-      body.should have_tag("input", :attributes => { :type => "text",
-                                                          :name => "post[title]" })
-    end
-    it "should have a body textarea" do
-      body.should have_tag("textarea", :attributes => { :name => "post[body]" })
-    end
-  end
-
-  context "with semantic fields for" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :title
-          f.input :body
-        end
-        f.instance_eval do
-          @object.author = User.new
-        end
-        f.semantic_fields_for :author do |author|
-          author.inputs :first_name, :last_name
-        end
-      end
-    end
-    it "should generate a nested text input once" do
-      body.scan("post_author_attributes_first_name_input").size.should == 1
-    end
-  end
-
-  context "with collection inputs" do
-    before do
-      User.create :first_name => "John", :last_name => "Doe"
-      User.create :first_name => "Jane", :last_name => "Doe"
-    end
-
-    describe "as select" do
-      let :body do
-        build_form do |f|
-          f.input :author
-        end
-      end
-      it "should create 2 options" do
-        body.scan(/\<option/).size.should == 3
-      end
-    end
-
-    describe "as radio buttons" do
-      let :body do
-        build_form do |f|
-          f.input :author, :as => :radio
-        end
-      end
-      it "should create 2 radio buttons" do
-        body.scan(/type=\"radio\"/).size.should == 2
-      end
-    end
-
-  end
-
-  context "with inputs 'for'" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :title
-          f.input :body
-        end
-        f.instance_eval do
-          @object.author = User.new
-        end
-        f.inputs :name => 'Author', :for => :author do |author|
-          author.inputs :first_name, :last_name
-        end
-      end
-    end
-    it "should generate a nested text input once" do
-      body.scan("post_author_attributes_first_name_input").size.should == 1
-    end
-    it "should add an author first name field" do
-      body.should have_tag("input", :attributes => { :name => "post[author_attributes][first_name]"})
-    end
-  end
-
-  context "with wrapper html" do
-    it "should set a class" do
-      body = build_form do |f|
-        f.input :title, :wrapper_html => { :class => "important" }
-      end
-      body.should have_tag("li", :attributes => {:class => "important string input optional stringish"})
-    end
-  end
-
-  context "with has many inputs" do
-    describe "with simple block" do
-      let :body do
-        build_form({:url => '/categories'}, Category.new) do |f|
-          f.object.posts.build
-          f.has_many :posts do |p|
-            p.input :title
-          end
-        end
-      end
-
-      it "should translate the association name in header" do
-        begin
-          I18n.backend.store_translations(:en, :activerecord => { :models => { :post => { :one => "Blog Post", :other => "Blog Posts" } } })
-          body.should have_tag('h3', 'Blog Posts')
-        ensure
-          I18n.backend.reload!
-        end
-      end
-
-      it "should use model name when there is no translation for given model in header" do
-        body.should have_tag('h3', 'Post')
-      end
-
-      it "should translate the association name in has many new button" do
-        begin
-          I18n.backend.store_translations(:en, :activerecord => { :models => { :post => { :one => "Blog Post", :other => "Blog Posts" } } })
-          body.should have_tag('a', 'Add New Blog Post')
-        ensure
-          I18n.backend.reload!
-        end
-      end
-
-      it "should use model name when there is no translation for given model in has many new button" do
-        body.should have_tag('a', 'Add New Post')
-      end
-
-      it "should render the nested form" do
-        body.should have_tag("input", :attributes => {:name => "category[posts_attributes][0][title]"})
-      end
-
-      it "should add a link to remove new nested records" do
-        Capybara.string(body).should have_css(".has_many > fieldset > ol > li > a", :class => "button", :href => "#", :content => "Delete")
-      end
-
-      it "should include the nested record's class name in the js" do
-        body.should have_tag("a", :attributes => { :onclick => /NEW_POST_RECORD/ })
-      end
-
-      it "should add a link to add new nested records" do
-        Capybara.string(body).should have_css(".has_many > fieldset > ol > li > a", :class => "button", :href => "#", :content => "Add New Post")
-      end
-    end
-
-    describe "with complex block" do
-      let :body do
-        build_form({:url => '/categories'}, Category.new) do |f|
-          f.object.posts.build
-          f.has_many :posts do |p,i|
-            p.input :title, :label => "Title #{i}"
-          end
-        end
-      end
-
-      it "should accept a block with a second argument" do
-        body.should have_tag("label", "Title 1")
-      end
-    end
-
-    pending "should render the block if it returns nil" do
-      body = build_form({:url => '/categories'}, Category.new) do |f|
-        f.object.posts.build
-        f.has_many :posts do |p|
-          p.input :title
-          nil
-        end
-      end
-
-      body.should have_tag("input", :attributes => {:name => "category[posts_attributes][0][title]"})
-    end
-  end
-
-  {
-    "input :title, :as => :string"               => /id\=\"post_title\"/,
-    "input :title, :as => :text"                 => /id\=\"post_title\"/,
-    "input :created_at, :as => :time_select"     => /id\=\"post_created_at_2i\"/,
-    "input :created_at, :as => :datetime_select" => /id\=\"post_created_at_2i\"/,
-    "input :created_at, :as => :date_select"     => /id\=\"post_created_at_2i\"/,
-  }.each do |source, regex|
-   it "should properly buffer #{source}" do
-     body = build_form do |f|
-       f.inputs do
-         f.instance_eval(source)
-         f.instance_eval(source)
-       end
-     end
-     body.scan(regex).size.should == 2
-   end
-  end
-
-  describe "datepicker input" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :created_at, :as => :datepicker
-        end
-      end
-    end
-    it "should generate a text input with the class of datepicker" do
-      body.should have_tag("input", :attributes => {  :type => "text",
-                                                          :class => "datepicker",
-                                                          :name => "post[created_at]" })
-    end
-  end
-
-  describe "inputs block with nil return value" do
-    let :body do
-      build_form do |f|
-        f.inputs do
-          f.input :title
-          nil
-        end
-      end
-    end
-
-    it "should generate a single input field" do
-      body.should have_tag("input", :attributes => { :type => "text", :name => "post[title]" })
-    end
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/generators/install_rails_3_1_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-
-if Rails.version[0..2] == '3.1'
-  describe "Installing in Rails 3.1" do
-
-    it "should add active_admin.css to app/assets/stylesheets/" do
-      File.exists?(Rails.root + "app/assets/stylesheets/active_admin.css.scss").should be_true
-    end
-
-    it "should add active_admin.js to app/assets/javascripts" do
-      File.exists?(Rails.root + "app/assets/javascripts/active_admin.js").should be_true
-    end
-
-  end
-end

data/vendor/deps/active_admin/spec/unit/helpers/collection_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Helpers::Collection do
-
-  include ActiveAdmin::Helpers::Collection
-
-  before(:all) do
-    Post.delete_all
-    Post.create!(:title => "A post")
-    Post.create!(:title => "A post")
-    Post.create!(:title => "An other post")
-  end
-
-  after(:all) do
-    Post.delete_all
-  end
-
-  describe "#collection_size" do
-    it "should return the collection size for an ActiveRecord class" do
-      collection_size(Post).should == 3
-    end
-
-    it "should return the collection size for an ActiveRecord::Relation" do
-      collection_size(Post.where(:title => "A post")).should == 2
-    end
-
-    it "should return the collection size for a collection with group by" do
-      collection_size(Post.group(:title)).should == 2
-    end
-
-    it "should return the collection size for a collection with group by, select and custom order" do
-      collection_size(Post.select("title, count(*) as nb_posts").group(:title).order("nb_posts")).should == 2
-    end
-
-    it "should take the defined collection by default" do
-      def collection; Post; end
-
-      collection_size.should == 3
-
-      def collection; Post.where(:title => "An other post"); end
-
-      collection_size.should == 1
-    end
-  end
-
-  describe "#collection_is_empty?" do
-    it "should return true when the collection is empty" do
-      collection_is_empty?(Post.where(:title => "Non existing post")).should be_true
-    end
-
-    it "should return false when the collection is not empty" do
-      collection_is_empty?(Post.where(:title => "A post")).should be_false
-    end
-
-    it "should take the defined collection by default" do
-      def collection; Post; end
-
-      collection_is_empty?.should be_false
-
-      def collection; Post.where(:title => "Non existing post"); end
-
-      collection_is_empty?.should be_true
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/helpers/scope_chain_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ScopeChain do
-
-  include ActiveAdmin::ScopeChain
-
-  describe "#scope_chain" do
-    let(:relation) { mock }
-
-    context "when Scope has a scope method" do
-      let(:scope) { ActiveAdmin::Scope.new :published }
-
-      it "should call the method on the relation and return it" do
-        relation.should_receive(:published).and_return(:scoped_relation)
-        scope_chain(scope, relation).should == :scoped_relation
-      end
-    end
-
-    context "when Scope has the scope method method ':all'" do
-      let(:scope) { ActiveAdmin::Scope.new :all }
-
-      it "should return the relation" do
-        scope_chain(scope, relation).should == relation
-      end
-    end
-
-    context "when Scope has a name and a scope block" do
-      let(:scope) { ActiveAdmin::Scope.new("My Scope"){|s| :scoped_relation } }
-
-      it "should instance_exec the block and return it" do
-        scope_chain(scope, relation).should == :scoped_relation
-      end
-    end
-  end
-end
-

data/vendor/deps/active_admin/spec/unit/helpers/settings_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-require 'active_admin/helpers/settings'
-
-describe ActiveAdmin::Settings do
-
-  # A Class with settings module included
-  let(:klass) do
-    Class.new do
-      include ActiveAdmin::Settings
-    end
-  end
-
-  it "should add a new setting with a default" do
-    klass.setting :my_setting, "Hello World"
-    klass.default_settings[:my_setting].should == "Hello World"
-  end
-
-  it "should initialize the defaults" do
-    klass.setting :my_setting, "Hello World"
-    klass.new.my_setting.should == "Hello World"
-  end
-
-  it "should support settings of nil" do
-    klass.setting :my_setting, :some_val
-    inst = klass.new
-    inst.my_setting = nil
-    inst.my_setting.should == nil
-  end
-
-end

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

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::MenuCollection do
-
-  let(:menus) { ActiveAdmin::MenuCollection.new }
-
-  describe "#add" do
-
-    it "should initialize a new menu when first item" do
-      menus.add :default, :label => "Hello World"
-
-      menus.fetch(:default).items.size.should == 1
-      menus.fetch(:default)["Hello World"].should be_an_instance_of(ActiveAdmin::MenuItem)
-    end
-
-    it "should add items to an existing menu" do
-      menus.add :default, :label => "Hello World"
-      menus.add :default, :label => "Hello World Again"
-
-      menus.fetch(:default).items.size.should == 2
-    end
-
-  end
-
-  describe "#clear!" do
-
-    it "should remove all menus" do
-      menus.add :default, :label => "Hello World"
-
-      menus.clear!
-
-      expect {
-        menus.fetch(:non_default_menu)
-      }.to raise_error(ActiveAdmin::MenuCollection::NoMenuError)
-
-    end
-
-  end
-
-  describe "#on_build" do
-
-    it "runs a callback when fetching a menu" do
-      menus.on_build do |m|
-        m.add :default, :label => "Hello World"
-      end
-
-      menus.fetch(:default)["Hello World"].should_not be_nil
-    end
-
-    it "re-runs the callbacks when the menu is cleared" do
-      menus.on_build do |m|
-        m.add :default, :label => "Hello World"
-      end
-
-      menus.fetch(:default)["Hello World"].should_not be_nil
-      menus.clear!
-      menus.fetch(:default)["Hello World"].should_not be_nil
-    end
-
-  end
-
-end