rails-excel-reporter 0.1.0

data/spec/rails_excel_reporter/base_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter::Base do
+  let(:sample_data) do
+    [
+      OpenStruct.new(id: 1, name: 'John Doe', email: 'john@example.com', created_at: Time.parse('2024-01-01')),
+      OpenStruct.new(id: 2, name: 'Jane Smith', email: 'jane@example.com', created_at: Time.parse('2024-01-02')),
+      OpenStruct.new(id: 3, name: 'Bob Johnson', email: 'bob@example.com', created_at: Time.parse('2024-01-03'))
+    ]
+  end
+
+  let(:report_class) do
+    Class.new(RailsExcelReporter::Base) do
+      attributes :id, :name, :email
+
+      def name
+        "#{object.name} (Custom)"
+      end
+    end
+  end
+
+  let(:report) { report_class.new(sample_data) }
+
+  describe 'class methods' do
+    describe '.attributes' do
+      it 'defines attributes for the report' do
+        expect(report_class.attributes).to contain_exactly(
+          { name: :id, header: 'Id' },
+          { name: :name, header: 'Name' },
+          { name: :email, header: 'Email' }
+        )
+      end
+    end
+
+    describe '.attribute' do
+      it 'adds a single attribute with custom header' do
+        klass = Class.new(RailsExcelReporter::Base)
+        klass.attribute :custom_field, header: 'Custom Header'
+
+        expect(klass.attributes).to contain_exactly(
+          { name: :custom_field, header: 'Custom Header' }
+        )
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#initialize' do
+      it 'initializes with collection' do
+        expect(report.collection).to eq(sample_data)
+      end
+
+      it 'accepts custom worksheet name' do
+        custom_report = report_class.new(sample_data, worksheet_name: 'Custom Sheet')
+        expect(custom_report.worksheet_name).to eq('Custom Sheet')
+      end
+
+      it 'accepts progress callback' do
+        callback = proc { |progress| }
+        custom_report = report_class.new(sample_data, &callback)
+        expect(custom_report.progress_callback).to eq(callback)
+      end
+    end
+
+    describe '#filename' do
+      it 'generates a filename with timestamp' do
+        allow(Time).to receive(:now).and_return(Time.parse('2024-01-15'))
+        expect(report.filename).to match(/report_report_2024_01_15\.xlsx/)
+      end
+    end
+
+    describe '#to_h' do
+      it 'returns hash representation' do
+        hash = report.to_h
+        expect(hash).to include(
+          :worksheet_name,
+          :attributes,
+          :data,
+          :collection_size,
+          :streaming
+        )
+      end
+    end
+
+    describe '#collection_size' do
+      it 'returns the size of the collection' do
+        expect(report.collection_size).to eq(3)
+      end
+    end
+
+    describe '#should_stream?' do
+      it 'returns false for small collections' do
+        expect(report.should_stream?).to be false
+      end
+
+      it 'returns true for large collections' do
+        large_data = (1..2000).map { |i| OpenStruct.new(id: i, name: "User #{i}") }
+        large_report = report_class.new(large_data)
+        expect(large_report.should_stream?).to be true
+      end
+    end
+
+    describe 'Excel generation' do
+      it 'generates Excel file' do
+        file = report.file
+        expect(file).to be_a(Tempfile)
+        expect(file.size).to be > 0
+      end
+
+      it 'generates Excel binary data' do
+        xlsx_data = report.to_xlsx
+        expect(xlsx_data).to be_a(String)
+        expect(xlsx_data.size).to be > 0
+        expect(xlsx_data[0, 4]).to eq("PK\x03\x04")
+      end
+
+      it 'saves to file' do
+        temp_path = '/tmp/test_report.xlsx'
+        report.save_to(temp_path)
+        expect(File.exist?(temp_path)).to be true
+        expect(File.size(temp_path)).to be > 0
+        File.delete(temp_path)
+      end
+    end
+
+    describe 'custom methods' do
+      it 'calls custom methods for attribute values' do
+        # Since we can't easily inspect binary xlsx data, test the underlying data
+        report_data = report.to_h[:data]
+        expect(report_data[0][1]).to eq('John Doe (Custom)')
+        expect(report_data[1][1]).to eq('Jane Smith (Custom)')
+      end
+    end
+  end
+
+  describe 'error handling' do
+    it 'raises error when no attributes are defined' do
+      empty_class = Class.new(RailsExcelReporter::Base)
+      empty_report = empty_class.new([])
+
+      expect { empty_report.to_xlsx }.to raise_error(RuntimeError, /No attributes defined/)
+    end
+  end
+
+  describe 'callbacks' do
+    let(:callback_class) do
+      Class.new(RailsExcelReporter::Base) do
+        attributes :id, :name
+
+        attr_reader :before_render_called, :after_render_called,
+                    :before_row_calls, :after_row_calls
+
+        def initialize(*args)
+          super
+          @before_render_called = false
+          @after_render_called = false
+          @before_row_calls = []
+          @after_row_calls = []
+        end
+
+        def before_render
+          @before_render_called = true
+        end
+
+        def after_render
+          @after_render_called = true
+        end
+
+        def before_row(object)
+          @before_row_calls << object
+        end
+
+        def after_row(object)
+          @after_row_calls << object
+        end
+      end
+    end
+
+    let(:callback_report) { callback_class.new(sample_data) }
+
+    it 'calls all callbacks in correct order' do
+      callback_report.to_xlsx
+
+      expect(callback_report.before_render_called).to be true
+      expect(callback_report.after_render_called).to be true
+      expect(callback_report.before_row_calls).to eq(sample_data)
+      expect(callback_report.after_row_calls).to eq(sample_data)
+    end
+  end
+end

data/spec/rails_excel_reporter/configuration_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter::Configuration do
+  let(:config) { RailsExcelReporter::Configuration.new }
+
+  describe 'default values' do
+    it 'has default date format' do
+      expect(config.date_format).to eq('%Y-%m-%d')
+    end
+
+    it 'has default streaming threshold' do
+      expect(config.streaming_threshold).to eq(1000)
+    end
+
+    it 'has default styles' do
+      expect(config.default_styles).to be_a(Hash)
+      expect(config.default_styles[:header]).to include(:bg_color, :fg_color, :bold)
+      expect(config.default_styles[:cell]).to include(:border)
+    end
+
+    it 'has default temp directory' do
+      expect(config.temp_directory).to eq(Dir.tmpdir)
+    end
+  end
+
+  describe 'customization' do
+    it 'allows setting custom date format' do
+      config.date_format = '%d/%m/%Y'
+      expect(config.date_format).to eq('%d/%m/%Y')
+    end
+
+    it 'allows setting custom streaming threshold' do
+      config.streaming_threshold = 500
+      expect(config.streaming_threshold).to eq(500)
+    end
+
+    it 'allows setting custom temp directory' do
+      config.temp_directory = '/custom/temp'
+      expect(config.temp_directory).to eq('/custom/temp')
+    end
+
+    it 'allows setting custom default styles' do
+      custom_styles = {
+        header: { bg_color: 'FF0000' },
+        cell: { border: { style: :medium } }
+      }
+      config.default_styles = custom_styles
+      expect(config.default_styles).to eq(custom_styles)
+    end
+  end
+end
+
+RSpec.describe RailsExcelReporter do
+  describe 'configuration' do
+    it 'returns the same configuration instance' do
+      config1 = RailsExcelReporter.configuration
+      config2 = RailsExcelReporter.configuration
+      expect(config1).to be(config2)
+    end
+
+    it 'allows configuration via block' do
+      RailsExcelReporter.configure do |config|
+        config.date_format = '%d-%m-%Y'
+        config.streaming_threshold = 2000
+      end
+
+      expect(RailsExcelReporter.config.date_format).to eq('%d-%m-%Y')
+      expect(RailsExcelReporter.config.streaming_threshold).to eq(2000)
+    end
+
+    it 'provides config alias' do
+      expect(RailsExcelReporter.config).to be(RailsExcelReporter.configuration)
+    end
+  end
+end

data/spec/rails_excel_reporter/controller_helpers_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter::ControllerHelpers do
+  let(:controller_class) do
+    Class.new do
+      include RailsExcelReporter::ControllerHelpers
+
+      attr_accessor :response
+
+      def initialize
+        @response = MockResponse.new
+      end
+
+      def send_data(data, options = {})
+        @sent_data = data
+        @send_options = options
+      end
+
+      def response_body=(body)
+        @response.body = body
+      end
+
+      attr_reader :sent_data, :send_options
+    end
+  end
+
+  let(:mock_response) do
+    Class.new do
+      attr_accessor :headers, :body
+
+      def initialize
+        @headers = {}
+      end
+    end
+  end
+
+  let(:controller) { controller_class.new }
+
+  let(:report_class) do
+    Class.new(RailsExcelReporter::Base) do
+      attributes :id, :name
+    end
+  end
+
+  let(:sample_data) do
+    [
+      OpenStruct.new(id: 1, name: 'John'),
+      OpenStruct.new(id: 2, name: 'Jane')
+    ]
+  end
+
+  let(:report) { report_class.new(sample_data) }
+
+  before do
+    stub_const('MockResponse', mock_response)
+  end
+
+  describe '#send_excel_report' do
+    it 'sends Excel data with default filename' do
+      controller.send_excel_report(report)
+
+      expect(controller.sent_data).to be_a(String)
+      expect(controller.send_options[:filename]).to match(/\.xlsx$/)
+      expect(controller.send_options[:type]).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+      expect(controller.send_options[:disposition]).to eq('attachment')
+    end
+
+    it 'sends Excel data with custom filename' do
+      controller.send_excel_report(report, filename: 'custom_report.xlsx')
+
+      expect(controller.send_options[:filename]).to eq('custom_report.xlsx')
+    end
+
+    it 'sends Excel data with custom disposition' do
+      controller.send_excel_report(report, disposition: 'inline')
+
+      expect(controller.send_options[:disposition]).to eq('inline')
+    end
+  end
+
+  describe '#stream_excel_report' do
+    it 'sets up streaming response headers' do
+      controller.stream_excel_report(report)
+
+      expect(controller.response.headers['Content-Type']).to eq('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
+      expect(controller.response.headers['Content-Disposition']).to match(/attachment; filename=/)
+      expect(controller.response.headers['Content-Transfer-Encoding']).to eq('binary')
+      expect(controller.response.headers['Last-Modified']).to be_present
+      expect(controller.response.body).to be_a(StringIO)
+    end
+
+    it 'uses custom filename in Content-Disposition' do
+      controller.stream_excel_report(report, filename: 'custom_stream.xlsx')
+
+      expect(controller.response.headers['Content-Disposition']).to include('custom_stream.xlsx')
+    end
+  end
+
+  describe '#excel_report_response' do
+    it 'uses send_excel_report for small reports' do
+      allow(report).to receive(:should_stream?).and_return(false)
+      expect(controller).to receive(:send_excel_report).with(report, {})
+
+      controller.excel_report_response(report)
+    end
+
+    it 'uses stream_excel_report for large reports' do
+      allow(report).to receive(:should_stream?).and_return(true)
+      expect(controller).to receive(:stream_excel_report).with(report, {})
+
+      controller.excel_report_response(report)
+    end
+
+    it 'passes options to the appropriate method' do
+      allow(report).to receive(:should_stream?).and_return(false)
+      expect(controller).to receive(:send_excel_report).with(report, { filename: 'test.xlsx' })
+
+      controller.excel_report_response(report, filename: 'test.xlsx')
+    end
+  end
+end

data/spec/rails_excel_reporter/streaming_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter::Streaming do
+  let(:small_data) do
+    (1..10).map { |i| OpenStruct.new(id: i, name: "User #{i}") }
+  end
+
+  let(:large_data) do
+    (1..2000).map { |i| OpenStruct.new(id: i, name: "User #{i}") }
+  end
+
+  let(:report_class) do
+    Class.new(RailsExcelReporter::Base) do
+      attributes :id, :name
+    end
+  end
+
+  describe 'streaming threshold' do
+    it 'has default streaming threshold' do
+      expect(report_class.streaming_threshold).to eq(RailsExcelReporter.config.streaming_threshold)
+    end
+
+    it 'can set custom streaming threshold' do
+      report_class.streaming_threshold = 500
+      expect(report_class.streaming_threshold).to eq(500)
+    end
+  end
+
+  describe '#should_stream?' do
+    it 'returns false for small collections' do
+      report = report_class.new(small_data)
+      expect(report.should_stream?).to be false
+    end
+
+    it 'returns true for large collections' do
+      report = report_class.new(large_data)
+      expect(report.should_stream?).to be true
+    end
+  end
+
+  describe '#collection_size' do
+    it 'calculates size for arrays' do
+      report = report_class.new(small_data)
+      expect(report.collection_size).to eq(10)
+    end
+
+    it 'uses count method when available' do
+      mock_collection = double('Collection')
+      allow(mock_collection).to receive(:count).and_return(100)
+
+      report = report_class.new(mock_collection)
+      expect(report.collection_size).to eq(100)
+    end
+
+    it 'falls back to size method' do
+      mock_collection = double('Collection')
+      allow(mock_collection).to receive(:respond_to?).with(:count).and_return(false)
+      allow(mock_collection).to receive(:respond_to?).with(:size).and_return(true)
+      allow(mock_collection).to receive(:size).and_return(50)
+
+      report = report_class.new(mock_collection)
+      expect(report.collection_size).to eq(50)
+    end
+  end
+
+  describe '#stream_data' do
+    it 'yields each item in small collections' do
+      report = report_class.new(small_data)
+      yielded_items = []
+
+      report.stream_data do |item|
+        yielded_items << item
+      end
+
+      expect(yielded_items).to eq(small_data)
+    end
+
+    it 'uses find_each for large ActiveRecord-like collections' do
+      mock_collection = double('ActiveRecord Collection')
+      allow(mock_collection).to receive(:respond_to?).with(:count).and_return(true)
+      allow(mock_collection).to receive(:count).and_return(2000)
+      allow(mock_collection).to receive(:respond_to?).with(:find_each).and_return(true)
+
+      yielded_items = []
+      allow(mock_collection).to receive(:find_each).with(batch_size: 1000) do |&block|
+        large_data.each(&block)
+      end
+
+      report = report_class.new(mock_collection)
+
+      report.stream_data do |item|
+        yielded_items << item
+      end
+
+      expect(yielded_items.size).to eq(2000)
+    end
+
+    it 'returns enumerator when no block given' do
+      report = report_class.new(small_data)
+      enumerator = report.stream_data
+
+      expect(enumerator).to be_a(Enumerator)
+      expect(enumerator.to_a).to eq(small_data)
+    end
+  end
+
+  describe '#with_progress_tracking' do
+    it 'tracks progress and yields items with progress info' do
+      report = report_class.new(small_data)
+      progress_updates = []
+
+      report.with_progress_tracking do |_item, progress|
+        progress_updates << progress
+      end
+
+      expect(progress_updates.size).to eq(10)
+      expect(progress_updates.first.current).to eq(1)
+      expect(progress_updates.first.total).to eq(10)
+      expect(progress_updates.first.percentage).to eq(10.0)
+      expect(progress_updates.last.current).to eq(10)
+      expect(progress_updates.last.percentage).to eq(100.0)
+    end
+
+    it 'calls progress callback when provided' do
+      callback_calls = []
+      callback = proc { |progress| callback_calls << progress }
+
+      report = report_class.new(small_data, &callback)
+
+      report.with_progress_tracking do |item, progress|
+        # Just iterate
+      end
+
+      expect(callback_calls.size).to eq(10)
+      expect(callback_calls.first.current).to eq(1)
+      expect(callback_calls.last.current).to eq(10)
+    end
+  end
+end

data/spec/rails_excel_reporter/styling_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter::Styling do
+  let(:styled_class) do
+    Class.new(RailsExcelReporter::Base) do
+      attributes :id, :name, :email
+
+      style :header, {
+        bg_color: 'FF0000',
+        fg_color: 'FFFFFF',
+        bold: true
+      }
+
+      style :id, {
+        alignment: { horizontal: :center }
+      }
+
+      style :name, {
+        bold: true,
+        font_size: 12
+      }
+    end
+  end
+
+  let(:sample_data) do
+    [
+      OpenStruct.new(id: 1, name: 'John', email: 'john@example.com'),
+      OpenStruct.new(id: 2, name: 'Jane', email: 'jane@example.com')
+    ]
+  end
+
+  let(:report) { styled_class.new(sample_data) }
+
+  describe 'class methods' do
+    describe '.style' do
+      it 'defines styles for targets' do
+        expect(styled_class.styles[:header]).to eq({
+                                                     bg_color: 'FF0000',
+                                                     fg_color: 'FFFFFF',
+                                                     bold: true
+                                                   })
+      end
+
+      it 'defines styles for columns' do
+        expect(styled_class.styles[:id]).to eq({
+                                                 alignment: { horizontal: :center }
+                                               })
+      end
+    end
+
+    describe '.styles' do
+      it 'returns all defined styles' do
+        expect(styled_class.styles).to include(:header, :id, :name)
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#get_header_style' do
+      it 'returns merged header style with defaults' do
+        header_style = report.get_header_style
+        expect(header_style[:bg_color]).to eq('FF0000')
+        expect(header_style[:bold]).to be true
+      end
+    end
+
+    describe '#get_column_style' do
+      it 'returns merged column style with defaults' do
+        id_style = report.get_column_style(:id)
+        expect(id_style[:alignment]).to eq({ horizontal: :center })
+      end
+
+      it 'returns default style for undefined columns' do
+        email_style = report.get_column_style(:email)
+        expect(email_style).to eq(RailsExcelReporter.config.default_styles[:cell])
+      end
+    end
+
+    describe '#build_caxlsx_style' do
+      it 'converts style options to caxlsx format' do
+        style_options = {
+          bg_color: 'FF0000',
+          fg_color: 'FFFFFF',
+          bold: true,
+          font_size: 12,
+          alignment: { horizontal: :center }
+        }
+
+        caxlsx_style = report.build_caxlsx_style(style_options)
+
+        expect(caxlsx_style[:bg_color]).to eq('FF0000')
+        expect(caxlsx_style[:fg_color]).to eq('FFFFFF')
+        expect(caxlsx_style[:b]).to be true
+        expect(caxlsx_style[:sz]).to eq(12)
+        expect(caxlsx_style[:alignment]).to eq({ horizontal: :center })
+      end
+    end
+
+    describe '#merge_styles' do
+      it 'merges multiple styles' do
+        styled_class.style :base, { bold: true, font_size: 10 }
+        styled_class.style :override, { font_size: 12, italic: true }
+
+        merged = report.merge_styles(:base, :override)
+
+        expect(merged[:bold]).to be true
+        expect(merged[:font_size]).to eq(12)
+        expect(merged[:italic]).to be true
+      end
+    end
+  end
+
+  describe 'inheritance' do
+    it 'inherits styles from parent class' do
+      child_class = Class.new(styled_class) do
+        style :email, { italic: true }
+      end
+
+      expect(child_class.styles).to include(:header, :id, :name, :email)
+      expect(child_class.styles[:header][:bold]).to be true
+      expect(child_class.styles[:email][:italic]).to be true
+    end
+  end
+end

data/spec/rails_excel_reporter_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe RailsExcelReporter do
+  describe 'configuration' do
+    it 'has a default configuration' do
+      expect(RailsExcelReporter.configuration).to be_a(RailsExcelReporter::Configuration)
+    end
+
+    it 'can be configured' do
+      RailsExcelReporter.configure do |config|
+        config.date_format = '%d/%m/%Y'
+        config.streaming_threshold = 500
+      end
+
+      expect(RailsExcelReporter.config.date_format).to eq('%d/%m/%Y')
+      expect(RailsExcelReporter.config.streaming_threshold).to eq(500)
+    end
+  end
+
+  describe 'version' do
+    it 'has a version number' do
+      expect(RailsExcelReporter::VERSION).not_to be nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'bundler/setup'
+require 'rails_excel_reporter'
+require 'rspec'
+require 'tempfile'
+require 'ostruct'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+  config.warnings = true
+
+  config.default_formatter = 'doc' if config.files_to_run.one?
+
+  config.profile_examples = 10
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.before(:each) do
+    RailsExcelReporter.instance_variable_set(:@configuration, nil)
+  end
+end