activeadmin-xls 1.0.5 → 2.0.3

data/spec/support/rails_template_with_data.rb

@@ -1,62 +0,0 @@
-# Use the default
-apply File.expand_path('../rails_template.rb', __FILE__)
-
-# Register Active Admin controllers
-%w[Post User Category].each do |type|
-  generate :'active_admin:resource', type
-end
-
-scopes = <<-SCOPES
-  scope :all, default: true
-
-  scope :drafts do |posts|
-    posts.where(["published_at IS NULL"])
-  end
-
-  scope :scheduled do |posts|
-    posts.where(["posts.published_at IS NOT NULL AND posts.published_at > ?", Time.now.utc])
-  end
-
-  scope :published do |posts|
-    posts.where(["posts.published_at IS NOT NULL AND posts.published_at < ?", Time.now.utc])
-  end
-
-  scope :my_posts do |posts|
-    posts.where(:author_id => current_admin_user.id)
-  end
-SCOPES
-
-inject_into_file 'app/admin/post.rb',
-                 scopes,
-                 after: "ActiveAdmin.register Post do\n"
-
-# Setup some default data
-append_file 'db/seeds.rb', <<-SEEDS
-
-  users = ['Jimi Hendrix', 'Jimmy Page', 'Yngwie Malmsteen', 'Eric Clapton', 'Kirk Hammett'].collect do |name|
-    first, last = name.split(" ")
-    User.create!  first_name: first,
-                  last_name: last,
-                  username: [first,last].join('-').downcase,
-                  age: rand(80)
-  end
-
-  categories = ['Rock', 'Pop Rock', 'Alt-Country', 'Blues', 'Dub-Step'].collect do |name|
-    Category.create! name: name
-  end
-
-  published_at_values = [Time.now.utc - 5.days, Time.now.utc - 1.day, nil, Time.now.utc + 3.days]
-
-  1_000.times do |i|
-    user = users[i % users.size]
-    cat = categories[i % categories.size]
-    published_at = published_at_values[i % published_at_values.size]
-    Post.create title: "Blog Post \#{i}",
-                body: "Blog post \#{i} is written by \#{user.username} about \#{cat.name}",
-                category_id: cat.id,
-                published_at: published_at,
-                author: user
-  end
-  SEEDS
-
-rake 'db:seed'

data/spec/support/templates/admin/stores.rb

@@ -1 +0,0 @@
-ActiveAdmin.register Store

data/spec/support/templates/cucumber.rb

@@ -1,24 +0,0 @@
-require File.expand_path('config/environments/test', Rails.root)
-
-# rails/railties/lib/rails/test_help.rb aborts if the environment is not 'test'. (Rails 3.0.0.beta3)
-# We can't run Cucumber/RSpec/Test_Unit tests in different environments then.
-#
-# For now, I patch StringInquirer so that Rails.env.test? returns true when Rails.env is 'test' or 'cucumber'
-#
-# https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/4458-rails-should-allow-test-to-run-in-cucumber-environment
-module ActiveSupport
-  class StringInquirer < String
-    def method_missing(method_name, *arguments)
-      if method_name.to_s[-1,1] == "?"
-        test_string = method_name.to_s[0..-2]
-        if test_string == 'test'
-          self == 'test' or self == 'cucumber'
-        else
-          self == test_string
-        end
-      else
-        super
-      end
-    end
-  end
-end

data/spec/support/templates/cucumber_with_reloading.rb

@@ -1,5 +0,0 @@
-require File.expand_path('config/environments/cucumber', Rails.root)
-
-Rails.application.class.configure do
-  config.cache_classes = false
-end

data/spec/support/templates/en.yml

@@ -1,15 +0,0 @@
-# Sample translations used to test ActiveAdmin's I18n integration.
-  xls:
-    post:
-      id: ID
-      title: Title
-      body: Content
-      published_at: Published On
-      author: Publisher
-      created_at: Created
-      updated_at: Updated
-  activerecord:
-    models:
-      store:
-        one: Bookstore
-        other: Bookstores

data/spec/xls/unit/build_download_format_links_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-describe ActiveAdmin::Views::PaginatedCollection do
-  def arbre(assigns = {}, helpers = mock_action_view, &block)
-    Arbre::Context.new(assigns, helpers, &block)
-  end
-
-  def render_arbre_component(assigns = {}, helpers = mock_action_view, &block)
-    arbre(assigns, helpers, &block).children.first
-  end
-
-  # Returns a fake action view instance to use with our renderers
-  def mock_action_view(assigns = {})
-    controller = ActionView::TestCase::TestController.new
-    ActionView::Base.send :include, ActionView::Helpers
-    ActionView::Base.send :include, ActiveAdmin::ViewHelpers
-    ActionView::Base.send :include, Rails.application.routes.url_helpers
-    ActionView::Base.new(ActionController::Base.view_paths, assigns, controller)
-  end
-
-  let(:view) do
-    view = mock_action_view
-    allow(view.request).to receive(:query_parameters) { { page: '1' } }
-    allow(view.request).to receive(:path_parameters) do
-      { controller: 'admin/posts', action: 'index' }
-    end
-    view
-  end
-
-  # Helper to render paginated collections within an arbre context
-  def paginated_collection(*args)
-    render_arbre_component({ paginated_collection_args: args }, view) do
-      paginated_collection(*paginated_collection_args)
-    end
-  end
-
-  let(:collection) do
-    posts = [Post.new(title: 'First Post')]
-    Kaminari.paginate_array(posts).page(1).per(5)
-  end
-
-  let(:pagination) { paginated_collection(collection) }
-
-  before do
-    allow(collection).to receive(:except) { collection } unless collection.respond_to? :except
-    allow(collection).to receive(:group_values) { [] } unless collection.respond_to? :group_values
-    allow(collection).to receive(:reorder) { collection }
-  end
-
-  it 'renders the xls download link' do
-    expect(pagination.children.last.content).to match(/XLS/)
-  end
-end

data/spec/xls/unit/builder_spec.rb

@@ -1,194 +0,0 @@
-require 'spec_helper'
-
-module ActiveAdmin
-  module Xls
-    describe Builder do
-      let(:builder) { Builder.new(Post) }
-      let(:content_columns) { Post.content_columns }
-
-      context 'the default builder' do
-        it 'has no header style' do
-          expect(builder.header_style).to eq({})
-        end
-        it 'has no i18n scope' do
-          expect(builder.i18n_scope).to be_nil
-        end
-        it 'has default columns' do
-          expect(builder.columns.size).to eq(content_columns.size + 1)
-        end
-      end
-
-      context 'customizing a builder' do
-        it 'deletes columns we tell it we dont want' do
-          builder.delete_columns :id, :body
-          expect(builder.columns.size).to eq(content_columns.size - 1)
-        end
-
-        it 'lets us say we dont want the header' do
-          builder.skip_header
-          expect(builder.instance_values['skip_header']).to be_truthy
-        end
-
-        it 'lets us add custom columns' do
-          builder.column(:hoge)
-          expect(builder.columns.size).to eq(content_columns.size + 2)
-        end
-
-        it 'lets us clear all columns' do
-          builder.clear_columns
-          expect(builder.columns.size).to eq(0)
-        end
-
-        context 'Using Procs for delayed content generation' do
-          let(:post) { Post.new(title: 'Hot Dawg') }
-
-          before do
-            builder.column(:hoge) do |resource|
-              "#{resource.title} - with cheese"
-            end
-          end
-
-          it 'stores the block when defining a column for later execution.' do
-            expect(builder.columns.last.data).to be_a(Proc)
-          end
-
-          it 'evaluates custom column blocks' do
-            expect(builder.columns.last.data.call(post)).to eq('Hot Dawg - with cheese')
-          end
-        end
-      end
-
-      context 'sheet generation without headers' do
-        let!(:users) { [User.new(first_name: 'bob', last_name: 'nancy')] }
-
-        let!(:posts) { [Post.new(title: 'bob', body: 'is a swell guy', author: users.first)] }
-
-        let!(:builder) do
-          Builder.new(Post, header_format: { weight: :bold }, i18n_scope: %i[xls post]) do
-            skip_header
-          end
-        end
-
-        before do
-          # disable clean up so we can get the book.
-          allow(builder).to receive(:clean_up) { false }
-          # @book = Spreadsheet.open(builder.serialize(posts))
-          builder.serialize(posts)
-          @book = builder.send(:book)
-          @collection = builder.collection
-        end
-
-        it 'does not serialize the header' do
-          expect(@book.worksheets.first[0, 0]).not_to eq('Title')
-        end
-      end
-
-      context 'whitelisted sheet generation' do
-        let!(:users) { [User.new(first_name: 'bob', last_name: 'nancy')] }
-
-        let!(:posts) do
-          [Post.new(title: 'bob', body: 'is a swell guy', author: users.first)]
-        end
-
-        let!(:builder) do
-          Builder.new(Post, header_style: {}, i18n_scope: %i[xls post]) do
-            skip_header
-            whitelist
-            column :title
-          end
-        end
-
-        before do
-          allow(User).to receive(:all) { users }
-          allow(Post).to receive(:all) { posts }
-          # disable clean up so we can get the book.
-          allow(builder).to receive(:clean_up) { false }
-          builder.serialize(Post.all)
-          @book = builder.send(:book)
-          @collection = builder.collection
-        end
-
-        it 'does not serialize the header' do
-          sheet = @book.worksheets.first
-          expect(sheet.column_count).to eq(1)
-          expect(sheet[0, 0]).to eq(@collection.first.title)
-        end
-      end
-
-      context 'Sheet generation with a highly customized configuration.' do
-        let!(:builder) do
-          Builder.new(Post, header_style: { size: 10, color: 'red' }, i18n_scope: %i[xls post]) do
-            delete_columns :id, :created_at, :updated_at
-            column(:author) do |resource|
-              "#{resource.author.first_name} #{resource.author.last_name}"
-            end
-            after_filter do |sheet|
-              row_number = sheet.dimensions[1]
-              sheet.update_row(row_number)
-              row_number += 1
-              sheet.update_row(row_number, 'Author Name', 'Number of Posts')
-              users = collection.map(&:author).uniq(&:id)
-              users.each do |user|
-                row_number += 1
-                sheet.update_row(row_number,
-                                 "#{user.first_name} #{user.last_name}",
-                                 user.posts.size)
-              end
-            end
-            before_filter do |sheet|
-              users = collection.map(&:author)
-              users.each do |user|
-                user.first_name = 'Set In Proc' if user.first_name == 'bob'
-              end
-              row_number = sheet.dimensions[1]
-              sheet.update_row(row_number, 'Created', Time.zone.now)
-              row_number += 1
-              sheet.update_row(row_number, '')
-            end
-          end
-        end
-
-        before do
-          Post.all.each(&:destroy)
-          User.all.each(&:destroy)
-          @user = User.create!(first_name: 'bob', last_name: 'nancy')
-          @post = Post.create!(title: 'bob',
-                               body: 'is a swell guy',
-                               author: @user)
-          # disable clean up so we can get the book.
-          allow(builder).to receive(:clean_up) { false }
-          builder.serialize(Post.all)
-          @book = builder.send(:book)
-          @collection = builder.collection
-        end
-
-        it 'provides the collection object' do
-          expect(@collection.count).to eq(Post.all.count)
-        end
-
-        it 'merges our customizations with the default header style' do
-          expect(builder.header_style[:size]).to eq(10)
-          expect(builder.header_style[:color]).to eq('red')
-          # expect(builder.header_style[:pattern_bg_color]).to eq('00')
-        end
-
-        it 'uses the specified i18n_scope' do
-          expect(builder.i18n_scope).to eq(%i[xls post])
-        end
-
-        it 'translates the header row based on our i18n scope' do
-          header_row = @book.worksheets.first.row(2)
-          expect(header_row).to eq(['Title', 'Content', 'Published On', 'Publisher'])
-        end
-
-        it 'processes the before filter' do
-          expect(@book.worksheets.first.cell(0, 0)).to eq('Created')
-        end
-
-        it 'lets us work against the collection in the before filter' do
-          expect(@book.worksheets.first.last_row[0]).to eq('Set In Proc nancy')
-        end
-      end
-    end
-  end
-end

data/spec/xls/unit/dsl_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-module ActiveAdmin
-  module Xls
-    describe ::ActiveAdmin::ResourceDSL do
-      context 'in a registration block' do
-        let(:builder) do
-          config = ActiveAdmin.register(Post) do
-            xls(i18n_scope: [:rspec], header_style: { size: 20 }) do
-              delete_columns :id, :created_at
-              column(:author) { |post| post.author.first_name }
-              before_filter do |sheet|
-                row_number = sheet.dimensions[1]
-                sheet.update_row(row_number, 'before_filter')
-              end
-              after_filter do |sheet|
-                row_number = sheet.dimensions[1]
-                sheet.update_row(row_number, 'after_filter')
-              end
-              skip_header
-            end
-          end
-          config.xls_builder
-        end
-
-        it 'uses our customized i18n scope' do
-          expect(builder.i18n_scope).to eq([:rspec])
-        end
-
-        it 'removed the columns we told it to ignore' do
-          %i[id create_at].each do |removed|
-            column_index = builder.columns.index { |col| col.name == removed }
-            expect(column_index).to be_nil
-          end
-        end
-
-        it 'added the columns we declared' do
-          added_index = builder.columns.index { |col| col.name == :author }
-          expect(added_index).not_to be_nil
-        end
-
-        it 'has a before filter set' do
-          expect(builder.instance_values['before_filter']).to be_a(Proc)
-        end
-        it 'has an after filter set' do
-          expect(builder.instance_values['after_filter']).to be_a(Proc)
-        end
-
-        it 'indicates that the header should be excluded' do
-          expect(builder.instance_values['skip_header']).to be_truthy
-        end
-
-        it 'updates the header style' do
-          expect(builder.header_style[:size]).to eq(20)
-        end
-      end
-    end
-  end
-end

data/spec/xls/unit/resource_controller_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-describe ActiveAdmin::ResourceController do
-  let(:mime) { Mime::Type.lookup_by_extension(:xls) }
-
-  let(:request) do
-    ActionController::TestRequest.new.tap do |test_request|
-      test_request.accept = mime
-    end
-  end
-
-  let(:response) { ActionController::TestResponse.new }
-
-  let(:controller) do
-    Admin::CategoriesController.new.tap do |controller|
-      controller.request = request
-      controller.response = response
-    end
-  end
-
-  let(:filename) do
-    "#{controller.resource_class.to_s.downcase.pluralize}-#{Time.now.strftime('%Y-%m-%d')}.xls"
-  end
-
-  it 'generates an xls filename' do
-    expect(controller.xls_filename).to eq(filename)
-  end
-
-  context 'when making requests with the xls mime type' do
-    it 'returns xls attachment when requested' do
-      controller.send :index
-      disposition = "attachment; filename=\"#{filename}\""
-      expect(response.headers['Content-Disposition']).to eq(disposition)
-      expect(response.headers['Content-Transfer-Encoding']).to eq('binary')
-    end
-
-    it 'returns max_csv_records for per_page' do
-      # this might need to go away!
-      max_csv_records = if controller.respond_to?(:max_csv_records, true)
-                          controller.send(:max_csv_records)
-                        else
-                          controller.send(:per_page)
-                        end
-      expect(controller.send(:per_page)).to eq(max_csv_records)
-    end
-
-    it 'uses to the default per_page when we do not specify xls mime type' do
-      controller.request.accept = 'text/html'
-      aa_default_per_page = ActiveAdmin.application.default_per_page
-      expect(controller.send(:per_page)).to eq(aa_default_per_page)
-    end
-  end
-end