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

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

@@ -1,183 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe ActiveAdmin, "Routing", :type => :routing do
-
-  before do
-    load_defaults!
-    reload_routes!
-  end
-
-  include Rails.application.routes.url_helpers
-
-  describe "root" do
-    before do
-      pending "Y U NO PASS?"
-    end
-    context "when default configuration" do
-      context "when in admin namespace" do
-        it "should route the admin dashboard" do
-          get('/admin').should route_to('admin/dashboard#index')
-        end
-      end
-
-      context "when in root namespace" do
-        before(:each) do
-          load_resources { ActiveAdmin.register(Post, :namespace => false) }
-          reload_routes!
-        end
-
-        it "should route the root dashboard" do
-          pending "Y U NO PASS?"
-
-          get('/').should route_to('dashboard#index')
-        end
-      end
-    end
-
-    context "when customized configuration to root to post#index" do
-      before do
-        @original_root = ActiveAdmin.application.root_to
-        ActiveAdmin.application.root_to = "posts#index"
-      end
-
-      after do
-        ActiveAdmin.application.root_to = @original_root
-        reload_routes!
-      end
-
-      context "when in admin namespace" do
-        before do
-          load_resources { ActiveAdmin.register(Post) }
-        end
-
-        it "should route to admin/posts#index" do
-          get('/admin').should route_to('admin/posts#index')
-        end
-      end
-
-      context "when in root namespace" do
-        before do
-          load_resources { ActiveAdmin.register(Post, :namespace => false) }
-        end
-
-        it "should route to posts#index" do
-          pending "Y U NO PASS?"
-
-          get('/').should route_to('posts#index')
-        end
-      end
-    end
-  end
-
-  describe "standard resources" do
-    context "when in admin namespace" do
-      it "should route the index path" do
-        admin_posts_path.should == "/admin/posts"
-      end
-
-      it "should route the show path" do
-        admin_post_path(1).should == "/admin/posts/1"
-      end
-
-      it "should route the new path" do
-        new_admin_post_path.should == "/admin/posts/new"
-      end
-
-      it "should route the edit path" do
-        edit_admin_post_path(1).should == "/admin/posts/1/edit"
-      end
-    end
-
-    context "when in root namespace" do
-      before(:each) do
-        load_resources { ActiveAdmin.register(Post, :namespace => false) }
-      end
-
-      it "should route the index path" do
-        posts_path.should == "/posts"
-      end
-
-      it "should route the show path" do
-        post_path(1).should == "/posts/1"
-      end
-
-      it "should route the new path" do
-        new_post_path.should == "/posts/new"
-      end
-
-      it "should route the edit path" do
-        edit_post_path(1).should == "/posts/1/edit"
-      end
-    end
-  end
-
-  describe "belongs to resource" do
-    it "should route the nested index path" do
-      admin_user_posts_path(1).should == "/admin/users/1/posts"
-    end
-
-    it "should route the nested show path" do
-      admin_user_post_path(1,2).should == "/admin/users/1/posts/2"
-    end
-
-    it "should route the nested new path" do
-      new_admin_user_post_path(1).should == "/admin/users/1/posts/new"
-    end
-
-    it "should route the nested edit path" do
-      edit_admin_user_post_path(1,2).should == "/admin/users/1/posts/2/edit"
-    end
-
-    context "with collection action" do
-      before do
-        load_resources do
-          ActiveAdmin.register(Post) do
-            belongs_to :user, :optional => true
-          end
-          ActiveAdmin.register(User) do
-            collection_action "do_something"
-          end
-        end
-      end
-
-      it "should properly route the collection action" do
-        { :get => "/admin/users/do_something" }.
-          should route_to({ :controller => 'admin/users',:action => 'do_something'})
-      end
-    end
-  end
-
-  describe "page" do
-    context "when default namespace" do
-      before(:each) do
-        load_resources { ActiveAdmin.register_page("Chocolate I lØve You!") }
-      end
-
-      it "should route to the page under /admin" do
-        admin_chocolate_i_love_you_path.should == "/admin/chocolate_i_love_you"
-      end
-
-      context "when in the root namespace" do
-        before(:each) do
-          load_resources { ActiveAdmin.register_page("Chocolate I lØve You!", :namespace => false) }
-        end
-
-        it "should route to page under /" do
-          chocolate_i_love_you_path.should == "/chocolate_i_love_you"
-        end
-      end
-
-      context "when singular page name" do
-        before(:each) do
-          load_resources { ActiveAdmin.register_page("Log") }
-        end
-
-        it "should not inject _index_ into the route name" do
-          admin_log_path.should == "/admin/log"
-        end
-      end
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/sass/helpers_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Sass::Helpers do
-
-  include ActiveAdmin::Sass::Helpers
-
-  context "when not using the asset pipeline" do
-
-    before(:all)do
-      @actual_rails_version = Rails::VERSION::MINOR
-      silence_warnings { Rails::VERSION::MINOR = 0 }
-    end
-
-    after(:all) do
-      silence_warnings { Rails::VERSION::MINOR = @actual_rails_version }
-    end
-
-    it "should generate an image asset path to /images/active_admin" do
-      active_admin_image_path(Sass::Script::String.new('test.jpg')).should ==
-          Sass::Script::String.new("/images/active_admin/test.jpg", true)
-    end
-
-  end
-
-  context "when using the asset pipeline" do
-    before(:all)do
-      @actual_rails_version = Rails::VERSION::MINOR
-      silence_warnings { Rails::VERSION::MINOR = 1 }
-    end
-
-    after(:all) do
-      silence_warnings { Rails::VERSION::MINOR = @actual_rails_version }
-    end
-
-    before do
-      assets = mock(:enabled => true)
-      Rails.application.config.stub!(:assets => assets)
-    end
-
-    it "should call the sass-rails asset helper" do
-      self.should_receive(:asset_path).with(Sass::Script::String.new("active_admin/test.jpg"), Sass::Script::String.new('image'))
-      active_admin_image_path(::Sass::Script::String.new('test.jpg'))
-    end
-
-  end
-
-end

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

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Scope do
-
-  describe "creating a scope" do
-    subject{ scope }
-
-    context "when just a scope method" do
-      let(:scope)        { ActiveAdmin::Scope.new :published }
-      its(:name)         { should == "Published"}
-      its(:id)           { should == "published"}
-      its(:scope_method) { should == :published }
-    end
-
-    context "when scope method is :all" do
-      let(:scope)        { ActiveAdmin::Scope.new :all }
-      its(:name)         { should == "All"}
-      its(:id)           { should == "all"}
-      # :all does not return a chain but an array of active record
-      # instances. We set the scope_method to nil then.
-      its(:scope_method) { should == nil }
-      its(:scope_block)  { should == nil }
-    end
-
-    context 'when a name and scope method is :all' do
-      let(:scope)        { ActiveAdmin::Scope.new 'Tous', :all }
-      its(:name)         { should eq 'Tous' }
-      its(:scope_method) { should be_nil }
-      its(:scope_block)  { should be_nil }
-    end
-
-    context "when a name and scope method" do
-      let(:scope)        { ActiveAdmin::Scope.new "With API Access", :with_api_access }
-      its(:name)         { should == "With API Access"}
-      its(:id)           { should == "with_api_access"}
-      its(:scope_method) { should == :with_api_access }
-    end
-
-    context "when a name and scope block" do
-      let(:scope)        { ActiveAdmin::Scope.new("My Scope"){|s| s } }
-      its(:name)         { should == "My Scope"}
-      its(:id)           { should == "my_scope"}
-      its(:scope_method) { should == nil }
-      its(:scope_block)  { should be_a(Proc)}
-    end
-  end # describe "creating a scope"
-
-  describe "#display_if_block" do
-
-    it "should return true by default" do
-      scope = ActiveAdmin::Scope.new(:default)
-      scope.display_if_block.call.should == true
-    end
-
-    it "should return the :if block if set" do
-      scope = ActiveAdmin::Scope.new(:with_block, nil, :if => proc{ false })
-      scope.display_if_block.call.should == false
-    end
-
-  end
-
-  describe "show_count" do
-
-    it "should allow setting of show_count to prevent showing counts" do
-      scope = ActiveAdmin::Scope.new(:default, nil, :show_count => false)
-      scope.show_count.should == false
-    end
-
-    it "should set show_count to true if not passed in" do
-      scope = ActiveAdmin::Scope.new(:default)
-      scope.show_count.should == true
-    end
-
-  end
-
-end

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

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-def it_should_have_view(key, value)
-  it "should have #{value} for view key '#{key}'" do
-    subject.send(key).should  == value
-  end
-end
-
-describe ActiveAdmin::ViewFactory do
-
-  it_should_have_view :global_navigation,    ActiveAdmin::Views::TabbedNavigation
-  it_should_have_view :site_title,           ActiveAdmin::Views::SiteTitle
-  it_should_have_view :action_items,         ActiveAdmin::Views::ActionItems
-  it_should_have_view :header,               ActiveAdmin::Views::Header
-  it_should_have_view :blank_slate,          ActiveAdmin::Views::BlankSlate
-  it_should_have_view :action_list_popover,  ActiveAdmin::Views::ActionListPopover
-
-  it_should_have_view :dashboard_page,       ActiveAdmin::Views::Pages::Dashboard
-  it_should_have_view :layout,               ActiveAdmin::Views::Pages::Layout
-
-end

data/vendor/deps/active_admin/spec/unit/view_helpers/download_format_links_helper_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper do
-
-  describe "class methods" do
-    before :each do
-
-      begin
-        # The mime type to be used in respond_to |format| style web-services in rails
-        Mime::Type.register "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", :xlsx
-      rescue NameError
-        puts "Mime module not defined. Skipping registration of xlsx"
-      end
-
-      class Foo
-        include ActiveAdmin::ViewHelpers::DownloadFormatLinksHelper
-      end
-    end
-
-    it "extends the class to add a formats class method that returns the default formats." do
-      Foo.formats.should == [:csv, :xml, :json]
-    end
-
-    it "does not let you alter the formats array directly" do
-      Foo.formats << :xlsx
-      Foo.formats.should == [:csv, :xml, :json]
-    end
-
-    it "allows us to add new formats" do
-      Foo.add_format :xlsx
-      Foo.formats.should == [:csv, :xml, :json, :xlsx]
-    end
-
-    it "raises an exception if you provide an unregisterd mime type extension" do
-      expect{ Foo.add_format :hoge }.to raise_error
-    end
-
-  end
-end

data/vendor/deps/active_admin/spec/unit/view_helpers/fields_for_spec.rb

@@ -1,50 +0,0 @@
-require 'active_admin/view_helpers/fields_for'
-
-describe ActiveAdmin::ViewHelpers::FormHelper, ".fields_for" do
-  include ActiveAdmin::ViewHelpers::FormHelper
-
-  it "should skip :action, :controller and :commit" do
-    fields_for_params(
-      :scope => "All", :action => "index", :controller => "PostController", :commit => "Filter", :utf8 => "Yes!").
-      should == [ { :scope => "All" } ]
-  end
-
-  it "should skip the except" do
-    fields_for_params({:scope => "All", :name => "Greg"}, :except => :name).
-      should == [ { :scope => "All" } ]
-  end
-
-  it "should allow an array for the except" do
-    fields_for_params({:scope => "All", :name => "Greg", :age => "12"}, :except => [:name, :age]).
-      should == [ { :scope => "All" } ]
-  end
-
-  it "should work with hashes" do
-    params = fields_for_params(:filters => { :name => "John", :age => "12" })
-
-    params.size.should == 2
-    params.should include({"filters[name]" => "John" })
-    params.should include({ "filters[age]" => "12" })
-  end
-
-  it "should work with nested hashes" do
-    fields_for_params(:filters => { :user => { :name => "John" }}).
-      should == [ { "filters[user][name]" => "John" } ]
-  end
-
-  it "should work with arrays" do
-    fields_for_params(:people => ["greg", "emily", "philippe"]).
-      should == [ { "people[]" => "greg" },
-                  { "people[]" => "emily" },
-                  { "people[]" => "philippe" } ]
-  end
-
-  it "should work with symbols" do
-    fields_for_params(:filter => :id).
-      should == [ { :filter => "id" } ]
-  end
-
-  it "should work with booleans" do
-    fields_for_params(:booleantest => false).should == [ { :booleantest => false } ]
-  end
-end

data/vendor/deps/active_admin/spec/unit/view_helpers/form_helper_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::ViewHelpers::FormHelper do
-  describe ".hidden_field_tags_for" do
-    let(:view) { action_view }
-
-    it "should render hidden field tags for params" do
-      view.hidden_field_tags_for(:scope => "All", :filter => "None").should == 
-        %{<input id="hidden_active_admin_scope" name="scope" type="hidden" value="All" />\n<input id="hidden_active_admin_filter" name="filter" type="hidden" value="None" />}
-    end
-
-    it "should generate not default id for hidden input" do
-      view.hidden_field_tags_for(:scope => "All")[/id="([^"]+)"/, 1].should_not == "scope"
-    end
-
-    it "should filter out the field passed via the option :except" do
-      view.hidden_field_tags_for({:scope => "All", :filter => "None"}, :except => :filter).should == 
-        %{<input id="hidden_active_admin_scope" name="scope" type="hidden" value="All" />}
-    end
-  end
-end
-

data/vendor/deps/active_admin/spec/unit/view_helpers/method_or_proc_helper_spec.rb

@@ -1,97 +0,0 @@
-require 'spec_helper'
-
-describe MethodOrProcHelper do
-  let(:receiver) { mock }
-
-  let(:context) do
-    obj = mock(:receiver_in_context => receiver)
-    obj.extend MethodOrProcHelper
-    obj
-  end
-
-  describe "#call_method_or_exec_proc" do
-
-    it "should call the method in the context when a symbol" do
-      context.call_method_or_exec_proc(:receiver_in_context).
-        should == receiver
-    end
-
-    it "should call the method in the context when a string" do
-      context.call_method_or_exec_proc("receiver_in_context").
-        should == receiver
-    end
-
-    it "should exec a proc in the context" do
-      test_proc = Proc.new{ raise "Success" if receiver_in_context }
-
-      expect {
-        context.call_method_or_exec_proc(test_proc)
-      }.to raise_error("Success")
-    end
-
-  end
-
-  describe "#call_method_or_proc_on" do
-
-    context "when a symbol" do
-
-      it 'should call the method on the receiver' do
-        receiver.should_receive(:hello).and_return("hello")
-
-        context.call_method_or_proc_on(receiver, "hello").
-          should == "hello"
-      end
-
-      it "should receive additional arguments" do
-        receiver.should_receive(:hello).with("world").and_return("hello world")
-
-        context.call_method_or_proc_on(receiver, :hello, "world").
-          should == "hello world"
-      end
-
-    end
-
-    context "when a proc" do
-
-      it "should exec the block in the context and pass in the receiver" do
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver,test_proc)
-        }.to raise_error("Success!")
-      end
-
-      it "should receive additional arguments" do
-        test_proc = Proc.new do |arg1, arg2|
-          raise "Success!" if arg1 == receiver_in_context && arg2 == "Hello"
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver, test_proc, "Hello")
-        }.to raise_error("Success!")
-      end
-
-    end
-
-    context "when a proc and :exec => false" do
-
-      it "should call the proc and pass in the receiver" do
-        obj_not_in_context = mock
-
-        test_proc = Proc.new do |arg|
-          raise "Success!" if arg == receiver && obj_not_in_context
-        end
-
-        expect {
-          context.call_method_or_proc_on(receiver,test_proc, :exec => false)
-        }.to raise_error("Success!")
-      end
-
-    end
-
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/views/components/action_list_popover_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Views::ActionListPopover do
-
-  let(:the_popover) do
-    arbre {
-      action_list_popover :id => "my_awesome_action_list_popover" do
-        action "My First Great Action", "#"
-        action "My Second Great Action", "http://www.google.com"
-      end
-    }.children.first
-  end
-
-  it "should have an id" do
-    the_popover.id.should == "my_awesome_action_list_popover"
-  end
-
-  describe "the action list" do
-    subject do
-      the_popover.find_by_class("popover_contents").first
-    end
-
-    its(:tag_name) { should eql("ul") }
-
-    its(:content){ should include("<li><a href=\"#\">My First Great Action</a></li>") }
-    its(:content){ should include("<li><a href=\"http://www.google.com\">My Second Great Action</a></li>") }
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/views/components/attributes_table_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Views::AttributesTable do
-
-  describe "creating with the dsl" do
-    let(:helpers) { action_view }
-
-    let(:post) do
-      post = Post.new :title => "Hello World", :body => nil
-      post.stub!(:id){ 1 }
-      post.stub!(:new_record?){ false }
-      post
-    end
-
-    let(:assigns){ { :post => post } }
-
-    # Loop through a few different ways to make the same table
-    # and ensure that they produce the same results
-    {
-      "when attributes are passed in to the builder methods" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post, :id, :title, :body
-        }
-      },
-      "when attributes are built using the block" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            rows :id, :title, :body
-          end
-        }
-      },
-      "when each attribute is passed in by itself" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            row :id
-            row :title
-            row :body
-          end
-        }
-      },
-      "when you create each row with a custom block" => proc {
-        render_arbre_component(assigns) {
-          attributes_table_for post do
-            row("Id")   { post.id }
-            row("Title"){ post.title }
-            row("Body") { post.body }
-          end
-        }
-      }
-
-    }.each do |context_title, table_decleration|
-      context context_title do
-        let(:table) { instance_eval &table_decleration }
-
-        it "should render a div wrapper with the class '.attributes_table'" do
-          table.tag_name.should == 'div'
-          table.attr(:class).should include('attributes_table')
-        end
-
-        it "should add id and type class" do
-          table.class_names.should include("post")
-          table.id.should == "attributes_table_post_1"
-        end
-
-        it "should render 3 rows" do
-          table.find_by_tag("tr").size.should == 3
-        end
-
-        describe "rendering the rows" do
-          [
-            ["Id" , "2"],
-            ["Title" , "Hello World"],
-            ["Body" , "<span class=\"empty\">Empty</span>"]
-          ].each_with_index do |set, i|
-            let(:title){ set[0] }
-            let(:content){ set[1] }
-            let(:current_row){ table.find_by_tag("tr")[i] }
-
-            describe "for #{set[0]}" do
-              it "should have the title '#{set[0]}'" do
-                current_row.find_by_tag("th").first.content.should == title
-              end
-              it "should have the content '#{set[1]}'" do
-                current_row.find_by_tag("td").first.content.chomp.strip.should == content
-              end
-            end
-          end
-        end # describe rendering rows
-
-      end
-    end # describe dsl styles
-
-    it "should allow html options for the row itself" do
-      table = render_arbre_component(assigns) {
-        attributes_table_for(post) do
-          row("Wee", :class => "custom_row", :style => "custom_style") { }
-        end
-      }
-      table.find_by_tag("tr").first.to_s.
-        split("\n").first.lstrip.
-          should == '<tr class="custom_row" style="custom_style">'
-    end
-
-    it "should allow html content inside the attributes table" do
-      table = render_arbre_component(assigns) {
-        attributes_table_for(post) do
-          row("ID"){ span(post.id, :class => 'id') }
-        end
-      }
-      table.find_by_tag("td").first.content.chomp.strip.should == "<span class=\"id\">1</span>"
-    end
-
-    it "should check if an association exists when an attribute has id in it" do
-      post.author = User.new(:username => "john_doe")
-      table = render_arbre_component(assigns) {
-        attributes_table_for post, :author_id
-      }
-      table.find_by_tag("td").first.content.should == "john_doe"
-    end
-
-  end
-
-end