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

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

@@ -1,182 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Views::TableFor do
-  describe "creating with the dsl" do
-
-    let(:collection) do
-      [Post.new(:title => "First Post"), Post.new(:title => "Second Post"), Post.new(:title => "Third Post")]
-    end
-
-    let(:assigns){ { :collection => collection } }
-    let(:helpers){ mock_action_view }
-
-    context "when creating a column with a symbol" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title
-          end
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        table.find_by_tag("th").first.content.should == "Title"
-      end
-
-      it "should create a table row for each element in the collection" do
-        table.find_by_tag("tr").size.should == 4 # 1 for head, 3 for rows
-      end
-
-      ["First Post", "Second Post", "Third Post"].each_with_index do |content, index|
-        it "should create a cell with #{content}" do
-          table.find_by_tag("td")[index].content.should == content
-        end
-      end
-    end
-
-    context "when creating many columns with symbols" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title
-            column :created_at
-          end
-        end
-      end
-
-      it "should create a table header based on the symbol" do
-        table.find_by_tag("th").first.content.should == "Title"
-        table.find_by_tag("th").last.content.should == "Created At"
-      end
-      
-      it "should add a class to each table header based on the col name" do
-        table.find_by_tag("th").first.class_list.should include("title")
-        table.find_by_tag("th").last.class_list.should  include("created_at")
-      end
-
-      it "should create a table row for each element in the collection" do
-        table.find_by_tag("tr").size.should == 4 # 1 for head, 3 for rows
-      end
-
-      it "should create a cell for each column" do
-        table.find_by_tag("td").size.should == 6
-      end
-      
-      it "should add a class for each cell based on the col name" do
-        table.find_by_tag("td").first.class_list.should include("title")
-        table.find_by_tag("td").last.class_list.should  include("created_at")
-      end
-    end
-
-    context "when creating a column with block content" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title do |post|
-              span(post.title)
-            end
-          end
-        end
-      end
-
-      it "should add a class to each table header based on the col name" do
-        table.find_by_tag("th").first.class_list.should include("title")
-      end
-
-      [ "<span>First Post</span>", 
-        "<span>Second Post</span>", 
-        "<span>Third Post</span>" ].each_with_index do |content, index|
-        it "should create a cell with #{content}" do
-          table.find_by_tag("td")[index].content.strip.should == content
-        end
-      end
-    end
-
-    context "when creating a column with multiple block content" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column :title do |post|
-              span(post.title)
-              span(post.title)
-            end
-          end
-        end
-      end
-
-      3.times do |index|
-        it "should create a cell with multiple elements in row #{index}" do
-          table.find_by_tag("td")[index].find_by_tag("span").size.should == 2
-        end
-      end
-    end
-
-
-    context "when creating many columns with symbols, blocks and strings" do
-      let(:table) do
-        render_arbre_component assigns, helpers do
-          table_for(collection) do
-            column "My Custom Title", :title
-            column :created_at , :class=>"datetime"
-          end
-        end
-      end
-
-
-      it "should add a class to each table header  based on class option or the col name" do
-        table.find_by_tag("th").first.class_list.should  include("my_custom_title")
-        table.find_by_tag("th").last.class_list.should  include("datetime")
-      end
-
-      it "should add a class to each cell based  on class option or the col name" do
-        table.find_by_tag("td").first.class_list.should include("my_custom_title")
-        table.find_by_tag("td").last.class_list.should  include("datetime")
-      end
-
-
-    end
-
-
-  end
-
-  describe "column sorting" do
-
-    def build_column(*args, &block)
-      ActiveAdmin::Views::TableFor::Column.new(*args, &block)
-    end
-
-    subject { table_column }
-
-    context "when default" do
-      let(:table_column){ build_column(:username) }
-      it { should be_sortable }
-      its(:sort_key){ should == "username" }
-    end
-
-    context "when a block given with no sort key" do
-      let(:table_column){ build_column("Username"){ } }
-      it { should_not be_sortable }
-    end
-
-    context "when a block given with a sort key" do
-      let(:table_column){ build_column("Username", :sortable => :username){ } }
-      it { should be_sortable }
-      its(:sort_key){ should == "username" }
-    end
-
-    context "when :sortable => false with a symbol" do
-      let(:table_column){ build_column(:username, :sortable => false) }
-      it { should_not be_sortable }
-    end
-
-    context "when :sortable => false with a symbol and string" do
-      let(:table_column){ build_column("Username", :username, :sortable => false) }
-      it { should_not be_sortable }
-    end
-
-    context "when :sortable column is an association" do
-      let(:table_column){ build_column("Category", :category, Post) }
-      it { should_not be_sortable }
-    end
-  end
-end

data/vendor/deps/active_admin/spec/unit/views/pages/layout_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe ActiveAdmin::Views::Pages::Layout do
-
-  let(:assigns){ {} }
-  let(:helpers) do 
-    helpers = mock_action_view
-
-    helpers.stub :active_admin_application => active_admin_application,
-                 :active_admin_config => mock('Config', :action_items? => nil, :breadcrumb => nil, :sidebar_sections? => nil),
-                 :active_admin_namespace => active_admin_namespace,
-                 :breadcrumb_links => [],
-                 :content_for => "",
-                 :csrf_meta_tag => "",
-                 :current_active_admin_user => nil,
-                 :current_active_admin_user? => false,
-                 :current_menu => mock('Menu', :items => []),
-                 :flash => {},
-                 :javascript_path => "/dummy/",
-                 :link_to => "",
-                 :render_or_call_method_or_proc_on => "",
-                 :stylesheet_link_tag => mock(:html_safe => ""),
-                 :view_factory => view_factory,
-                 :params => {:controller => 'UsersController', :action => 'edit'}
-
-    helpers
-  end
-
-  let(:active_admin_namespace){ ActiveAdmin::Namespace.new(ActiveAdmin::Application.new, :myspace) }
-  let(:active_admin_application){ ActiveAdmin.application }
-  let(:view_factory) { ActiveAdmin::ViewFactory.new }
-
-  let(:layout) do
-    render_arbre_component assigns, helpers do
-      insert_tag ActiveAdmin::Views::Pages::Layout
-    end
-  end
-
-  it "should be the @page_title if assigned in the controller" do
-    assigns[:page_title] = "My Page Title"
-
-    layout.title.should == "My Page Title"
-  end
-
-  it "should be the default translation" do
-    helpers.params[:action] = "edit"
-
-    layout.title.should == "Edit"
-  end
-
-  describe "the body" do
-
-    it "should have class 'active_admin'" do
-      layout.build.class_list.should include 'active_admin'
-    end
-
-    it "should have namespace class" do
-      layout.build.class_list.should include "#{active_admin_namespace.name}_namespace"
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/views/pages/show_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-
-describe ActiveAdmin::Views::Pages::Show do
-
-  describe "the resource" do
-    let(:helpers) { mock(:resource => resource) }
-    let(:arbre_context) { OpenStruct.new(:helpers => helpers) }
-
-    context 'when the resource does not respond to #decorator' do
-      let(:resource) { 'Test Resource' }
-
-      it "normally returns the resource" do
-        page = ActiveAdmin::Views::Pages::Show.new(arbre_context)
-        page.resource.should == 'Test Resource'
-      end
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/spec/unit/views/tabbed_navigation_spec.rb

@@ -1,152 +0,0 @@
-require 'spec_helper'
-
-include ActiveAdmin
-describe ActiveAdmin::Views::TabbedNavigation do
-
-  let(:menu){ ActiveAdmin::Menu.new }
-
-  let(:assigns){ { :active_admin_menu => menu } }
-  let(:helpers){ mock_action_view }
-
-  let(:tabbed_navigation) do 
-    arbre(assigns, helpers) {
-      insert_tag(ActiveAdmin::Views::TabbedNavigation, active_admin_menu)
-    }.children.first
-  end
-
-  let(:html) { tabbed_navigation.to_s }
-
-  before do
-    helpers.stub!(:admin_logged_in?).and_return(false)
-  end
-
-  describe "rendering a menu" do
-
-    before do
-      menu.add :label => "Blog Posts", :url => :admin_posts_path
-
-      menu.add :label => "Reports",	:url => "/admin/reports" do |reports|
-        reports.add :label => "A Sub Reports", :url => "/admin/a-sub-reports"
-        reports.add :label => "B Sub Reports", :url => "/admin/b-sub-reports"
-        reports.add :label => proc{ "Label Proc Sub Reports" }, :url => "/admin/label-proc-sub-reports"
-      end
-
-      menu.add :label => "Administration", :url => "/admin/administration" do |administration|
-        administration.add :label => "User administration", 
-                           :url => '/admin/user-administration', 
-                           :priority => 10, 
-                           :if => proc { false }
-      end
-
-      menu.add :label => "Management", :url => "#" do |management|
-        management.add :label => "Order management", 
-                       :url => '/admin/order-management', 
-                       :priority => 10, 
-                       :if => proc { false }
-        management.add :label => "Bill management", 
-                       :url => '/admin/bill-management', 
-                       :priority => 10, 
-                       :if => :admin_logged_in?
-      end
-
-
-    end
-
-    it "should generate a ul" do
-      html.should have_tag("ul")
-    end
-
-    it "should generate an li for each item" do
-      html.should have_tag("li", :parent => { :tag => "ul" })
-    end
-
-    it "should generate a link for each item" do
-      html.should have_tag("a", "Blog Posts", :attributes => { :href => '/admin/posts' })
-    end
-
-    it "should generate a nested list for children" do
-      html.should have_tag("ul", :parent => { :tag => "li" })
-    end
-
-    it "should generate a nested list with li for each child" do
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "a_sub_reports"})
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "b_sub_reports"})
-    end
-
-    it "should generate a valid dom_id from a label proc" do
-      html.should have_tag("li", :parent => { :tag => "ul" }, :attributes => {:id => "label_proc_sub_reports"})
-    end
-
-    it "should not generate a link for user administration" do
-      html.should_not have_tag("a", "User administration", :attributes => { :href => '/admin/user-administration' })
-    end
-
-    it "should generate the administration parent menu" do
-      html.should have_tag("a", "Administration", :attributes => { :href => '/admin/administration' })
-    end
-
-    it "should not generate a link for order management" do
-      html.should_not have_tag("a", "Order management", :attributes => { :href => '/admin/order-management' })
-    end
-
-    it "should not generate a link for bill management" do
-      html.should_not have_tag("a", "Bill management", :attributes => { :href => '/admin/bill-management' })
-    end
-
-    it "should not generate the management parent menu" do
-      html.should_not have_tag("a", "Management", :attributes => { :href => '#' })
-    end
-
-    describe "marking current item" do
-
-      it "should add the 'current' class to the li" do
-        assigns[:current_tab] = menu["Blog Posts"]
-        html.should have_tag("li", :attributes => { :class => "current" })
-      end
-
-      it "should add the 'current' and 'has_nested' classes to the li and 'current' to the sub li" do
-        assigns[:current_tab] = menu["Reports"]["A Sub Reports"]
-        html.should have_tag("li", :attributes => { :id => "reports", :class => /current/ })
-        html.should have_tag("li", :attributes => { :id => "reports", :class => /has_nested/ })
-        html.should have_tag("li", :attributes => { :id => "a_sub_reports", :class => "current" })
-      end
-
-    end
-
-  end
-
-  describe "returning the menu items to display" do
-
-    it "should return one item with no if block" do
-      menu.add :label => "Hello World", :url => "/"
-      tabbed_navigation.menu_items.should == menu.items
-    end
-
-    it "should not include menu items with an if block that returns false" do
-      menu.add :label => "Don't Show", :url => "/", :priority => 10, :if => proc{ false }
-      tabbed_navigation.menu_items.should == []
-    end
-
-    it "should not include menu items with an if block that calls a method that returns false" do
-      menu.add :label => "Don't Show", :url => "/", :priority => 10, :if => :admin_logged_in?
-      tabbed_navigation.menu_items.should == []
-    end
-
-    it "should not display any items that have no children to display" do
-      menu.add :label => "Parent", :url => "#" do |p|
-        p.add :label => "Child", :url => "/", :priority => 10, :if => proc{ false }
-      end
-      tabbed_navigation.menu_items.should == []
-    end
-
-    it "should display a parent that has a child to display" do
-      menu.add :label => "Parent", :url => "#" do |p|
-        p.add :label => "Hidden Child", :url => "/", :priority => 10, :if => proc{ false }
-        p.add :label => "Child", :url => "/"
-      end
-      tabbed_navigation.should have(1).menu_items
-    end
-
-  end
-
-end

data/vendor/deps/active_admin/tasks/docs.rake

@@ -1,39 +0,0 @@
-namespace :docs do
-
-  def rdoc_to_markdown(content)
-    content.gsub(/^ ?(=+) /) do |m|
-      m.gsub('=', '#')
-    end
-  end
-
-  def prepare_docstring(content)
-    content = rdoc_to_markdown(content)
-    "<!-- Please don't edit this file. It will be clobbered. -->\n\n#{content}"
-  end
-
-  def filename_from_module(mod)
-    mod.name.to_s.underscore.gsub('_', '-')
-  end
-
-  def write_docstrings_to(path, mods)
-    mods.each do |mod|
-      File.open("#{path}/#{filename_from_module(mod)}.md", 'w+') do |f|
-        f << prepare_docstring(mod.docstring)
-      end
-    end
-  end
-
-  desc "Update docs in the docs folder"
-  task :build do
-    require 'yard'
-    require 'active_support/all'
-
-    YARD::Registry.load!
-    views = YARD::Registry.at("ActiveAdmin::Views")
-
-    # Index Types
-    index_types = views.children.select{|obj| obj.name.to_s =~ /^IndexAs/ }
-    write_docstrings_to "docs/3-index-pages", index_types
-  end
-
-end

data/vendor/deps/active_admin/tasks/js.rake

@@ -1,32 +0,0 @@
-namespace :js do
-
-  desc "Compile the JS for Rails apps without Asset Pipeline"
-  task :compile do
-    require 'sprockets'
-    require 'uglifier'
-    require 'fileutils'
-
-    root_dir = File.expand_path(File.join("..", ".."), __FILE__)
-    js_dir = File.join(root_dir, "app", "assets", "javascripts", "active_admin")
-    generated_file = File.join(root_dir, 'lib', 'generators', 'active_admin', 'assets', 'templates', '3.0', 'active_admin.js')
-
-    # The base.js file requires jquery. We don't need jquery to
-    # compile the assets, however Sprockets will try to look it up
-    # and raise an exception. Insteaad, we move the file out of the directory
-    # then put it back after we compile.
-    base_js = File.join(js_dir, "base.js")
-    tmp_base_js = File.join(root_dir, "base.js")
-    FileUtils.mv base_js, tmp_base_js
-
-    env = Sprockets::Environment.new
-    env.js_compressor = ::Uglifier.new
-    env.append_path js_dir
-
-    File.open generated_file, "w+" do |f|
-      f << env["application"]
-    end
-
-    FileUtils.mv tmp_base_js, base_js
-  end
-
-end

data/vendor/deps/active_admin/tasks/parallel_tests.rake

@@ -1,60 +0,0 @@
-require 'parallel'
-
-desc "Run the full suite using parallel_tests to run on multiple cores"
-task :parallel_tests => ['parallel:setup_parallel_tests', 'parallel:spec', 'parallel:features', 'cucumber:class_reloading']
-
-namespace :parallel do
-
-  def rails_app_rake(task)
-    require 'rails/version'
-    system "cd spec/rails/rails-#{Rails::VERSION::STRING}; rake #{task}"
-  end
-
-  task :after_setup_hook do
-    rails_app_rake "parallel:load_schema"
-    rails_app_rake "parallel:create_cucumber_db"
-    rails_app_rake "parallel:load_schema_cucumber_db"
-  end
-
-  def parallel_tests_setup?
-    require 'rails/version'
-    database_config = File.join "spec", "rails", "rails-#{Rails::VERSION::STRING}", "config", "database.yml"
-    File.exists?(database_config) && File.read(database_config).include?("TEST_ENV_NUMBER")
-  end
-
-  desc "Setup parallel_tests DBs"
-  task :setup_parallel_tests do
-    unless parallel_tests_setup?
-      puts "parallel_tests is not set up. (Re)building spec/rails/rails-#{Rails::VERSION::STRING} App. Please wait."
-      require 'rails/version'
-      system("rm -Rf spec/rails/rails-#{Rails::VERSION::STRING}")
-      Rake::Task['setup'].invoke
-    end
-  end
-
-  def run_in_parallel(command)
-    system("ENV['TEST_ENV_NUMBER']=#{Parallel.processor_count} #{command}")
-  end
-
-  desc "Run the specs in parallel"
-  task :spec => :setup_parallel_tests do
-    run_in_parallel "parallel_rspec spec/"
-  end
-
-  namespace :spec do
-
-    %w(unit integration).each do |type|
-      desc "Run the #{type} specs in parallel"
-      task type => :setup_parallel_tests do
-        run_in_parallel "parallel_rspec spec/#{type}"
-      end
-    end
-
-  end
-
-  desc "Run the cucumber features in parallel"
-  task :features => :setup_parallel_tests do
-    run_in_parallel "parallel_cucumber features/"
-  end
-
-end

data/vendor/deps/active_admin/tasks/test.rake

@@ -1,76 +0,0 @@
-desc "Creates a test rails app for the specs to run against"
-task :setup do
-  require 'rails/version'
-  system("mkdir spec/rails") unless File.exists?("spec/rails")
-  system "bundle exec rails new spec/rails/rails-#{Rails::VERSION::STRING} -m spec/support/rails_template.rb"
-  Rake::Task['parallel:after_setup_hook'].invoke
-end
-
-# Run specs and cukes
-desc "Run the full suite using 1 core"
-task :test => ['spec:unit', 'spec:integration', 'cucumber', 'cucumber:class_reloading']
-
-namespace :test do
-
-  def run_tests_against(*versions)
-    current_version = detect_rails_version if File.exists?("Gemfile.lock")
-
-    versions.each do |version|
-      puts
-      puts "== Using Rails #{version}"
-
-      cmd "./script/use_rails #{version}"
-      cmd "bundle exec rspec spec"
-      cmd "bundle exec cucumber features"
-      cmd "bundle exec cucumber -p class-reloading features"
-    end
-
-    cmd "./script/use_rails #{current_version}" if current_version
-  end
-
-  desc "Run the full suite against the important versions of rails"
-  task :major_supported_rails do
-    run_tests_against *TRAVIS_RAILS_VERSIONS
-  end
-
-  desc "Alias for major_supported_rails"
-  task :all => :major_supported_rails
-
-end
-
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-namespace :spec do
-
-  desc "Run the unit specs"
-  RSpec::Core::RakeTask.new(:unit) do |t|
-    t.pattern = "spec/unit/**/*_spec.rb"
-  end
-
-  desc "Run the integration specs"
-  RSpec::Core::RakeTask.new(:integration) do |t|
-    t.pattern = "spec/integration/**/*_spec.rb"
-  end
-
-end
-
-
-require 'cucumber/rake/task'
-
-Cucumber::Rake::Task.new(:cucumber) do |t|
-  t.profile = 'default'
-end
-
-namespace :cucumber do
-
-  Cucumber::Rake::Task.new(:wip, "Run the cucumber scenarios with the @wip tag") do |t|
-    t.profile = 'wip'
-  end
-
-  Cucumber::Rake::Task.new(:class_reloading, "Run the cucumber scenarios that test reloading") do |t|
-    t.profile = 'class-reloading'
-  end
-
-end

data/vendor/deps/active_admin/tasks/yard.rake

@@ -1,6 +0,0 @@
-require 'yard'
-require 'yard/rake/yardoc_task'
-
-YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb']
-end