axlsx_report 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45c3786fefc932fcf9f891788cfb0c3fcf4d885d
+  data.tar.gz: 681f81d9bb9042f0da7200688d80229e368574d1
+SHA512:
+  metadata.gz: 9b7f8e17f841fce40e7d0fdf4f687e9b3ffbd8583a3846eb0ce456ef1e8929ddf2ae536a45ba768cf87bce7f0df5174dd20e1a06677c5b36b28cfdf55e9fe837
+  data.tar.gz: 7f973dd5e6d1a139e46274c2570c8ac89990f6255c45067d146689e3fda510a9d34a6d4584c3e8ed64254687ae39384abf55e9e87834bef64e3fb67d47fa05de

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.xlsx

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in axlsx_report.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Alexey Volochnev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# AxlsxReport
+
+Declarative excel reports based on [axlsx](https://github.com/randym/axlsx).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'axlsx_report'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install axlsx_report
+
+## Usage
+
+```ruby
+require 'axlsx_report'
+
+class BaseReport < AxlsxReport::Base
+  column 'Number' do |i|
+    i
+  end
+
+  column 'Square' do |i|
+    i * i
+  end
+end
+
+report = BaseReport.new
+
+(1..10).each do |i|
+  report << i
+end
+
+report.save('base_report.xlsx')
+```
+
+Find more examples in examples folder.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/avolochnev/axlsx_report.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/axlsx_report.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'axlsx_report/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "axlsx_report"
+  spec.version       = AxlsxReport::VERSION
+  spec.authors       = ["Alexey Volochnev"]
+  spec.email         = ["alexey.volochnev@gmail.com"]
+
+  spec.summary       = %q{Declarative excel reports based on axlsx.}
+  spec.homepage      = "https://github.com/avolochnev/axlsx_report"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'axlsx', '~> 2.0', '>= 2.0.1'
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'roo', '~> 1.13', '>= 1.13.2'
+end

data/examples/base_report.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'axlsx_report'
+
+class BaseReport < AxlsxReport::Base
+  column 'Integer' do |i|
+    i
+  end
+
+  column 'Square' do |i|
+    i * i
+  end
+end
+
+if __FILE__ == $0
+  report = BaseReport.new
+  (1..10).each { |i| report << i }
+  report.save('base_report.xlsx')
+end
+
+

data/examples/group_report.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'axlsx_report'
+
+class GroupReport < AxlsxReport::Base
+  column 'Integer' do |i|
+    i
+  end
+
+  # Define group of columns with merged group header
+  group 'Calculations' do
+    column 'Square' do |i|
+      i * i
+    end
+
+    column 'Sqrt' do |i|
+      Math.sqrt(i)
+    end
+  end
+end
+
+if __FILE__ == $0
+  report = GroupReport.new
+  (1..10).each { |i| report << i }
+  report.save('group_report.xlsx')
+end
+
+

data/examples/lambda_report.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'axlsx_report'
+
+class LambdaReport < AxlsxReport::Base
+  # proc without params called in context of given object
+  column 'Integer', -> { self }
+  column 'Odd?', -> { odd? }, width: 7
+  column 'Even?', -> { even? }, width: 7
+end
+
+if __FILE__ == $0
+  report = LambdaReport.new
+  (1..10).each { |i| report << i }
+  report.save('lambda_report.xlsx')
+end
+
+

data/examples/width_report.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'axlsx_report'
+
+class WidthReport < AxlsxReport::Base
+  column 'Integer', width: 20 do |i|
+    i
+  end
+
+  column 'Square', width: 20 do |i|
+    i * i
+  end
+end
+
+if __FILE__ == $0
+  report = WidthReport.new
+  (1..10).each { |i| report << i }
+  report.save('width_report.xlsx')
+end
+
+

data/lib/axlsx_report.rb

@@ -0,0 +1,5 @@
+require 'axlsx_report/version'
+require 'axlsx_report/base'
+
+module AxlsxReport
+end

data/lib/axlsx_report/base.rb

@@ -0,0 +1,355 @@
+require 'axlsx'
+require_relative 'column_name_conv'
+require_relative 'group'
+require_relative 'column'
+
+module AxlsxReport
+  class Base
+    include ColumnNameConv
+
+    # Creates new report.
+    # By default creates own Axlsx::Package.
+    # @param [Axlsx::Package] package - provide existing package to add report sheet to combined document.
+    def initialize(package = nil)
+      @package = package || Axlsx::Package.new
+    end
+
+    # Define report column.
+    #
+    # Usage:
+    #   Human = Struct.new(:first_name, :last_name, :birthday)
+    #   class Report < AxlsxReport::Base
+    #     # calculate column value with block:
+    #     column 'First Name', width: 10 do |human|
+    #       human.first_name
+    #     end
+    #     # or lambda in context of given object
+    #     column 'Last Name', -> { last_name }, width: 15
+    #     # or chagne context using with:
+    #     column 'Age', -> { Date.today.year - year }, with: :birthday
+    #   end
+    #
+    # @see Column#initialize for options description
+    #
+    # @param [String] name - column header
+    # @param [Proc] callable - use proc or lambda instead of block to get cell value. Optional.
+    # @param [Hash] options - last param,
+    # @param block
+    # args: callable = nil, options = {}
+    def self.column(col_name, *args, &block)
+      @columns ||= []
+      options =
+        if args.last.is_a? Hash
+          args.pop
+        else
+          {}
+        end
+      options[:group] = @current_group if @current_group
+      callable = args.first || block
+      @columns << Column.new(col_name, callable, options)
+    end
+
+    # Define group of columns
+    #
+    # Usage:
+    #   Human = Struct.new(:first_name, :last_name, :birthday)
+    #   class Report < AxlsxReport::Base
+    #     group 'Name' do
+    #       column 'First', &:first_name
+    #       column 'Last',  &:last_name
+    #     end
+    #     column 'Birthday', &:birthday
+    #   end
+    #
+    # @param [String] name group name
+    def self.group(name, &block)
+      @columns ||= []
+      unless @groups
+        @groups = []
+        define_method :groups do
+          self.class.instance_eval { @groups }
+        end
+      end
+      raise 'Nested groups are not implemented yet' if @current_group
+      @current_group = Group.new(name, @columns.length)
+      @groups << @current_group
+      instance_exec(&block)
+      @current_group.end_index = @columns.length - 1
+      @current_group = nil
+    end
+
+    # Define group row height.
+    # Used if any groups are defiend. Autoheight is used by default
+    # @param [Integer] num group row height
+    def self.group_height(num)
+      define_method(:group_height) { num }
+    end
+
+    # Define head row height.
+    # Autoheight is used by default
+    # @param [Integer] num head row height
+    def self.head_height(num)
+      define_method(:head_height) { num }
+    end
+
+    # Add 1,2,3...N row below head row
+    def self.numerate_columns
+      define_method(:numerate_columns) { true }
+    end
+
+    # Define sheet name.
+    #
+    # @param [String] name (nil) static sheet name.
+    # @param block dinamic sheet name (if given)
+    def self.sheet_name(name = nil, &block)
+      if block_given?
+        define_method(:sheet_name, &block)
+      else
+        define_method(:sheet_name) { name }
+      end
+    end
+
+    # Add row to the report.
+    # @param [Any] obj object providing the data for columns
+    def <<(obj)
+      row = columns.map { |column| column.value(self, obj) }
+      add_totals row
+      sheet.add_row row, row_options
+    end
+
+    # Returns sheet name.
+    #
+    # May be overriden to provide custom sheet name
+    # @see Base.sheet_name
+    def sheet_name
+      'Sheet1'
+    end
+
+    # def run(file = nil, enum = nil)
+    #   file = file_name unless file
+    #   enum = enumerator if enum.nil? && !block_given?
+    #   if enum
+    #     enum.each do |obj|
+    #       self << obj
+    #     end
+    #   elsif block_given?
+    #     yield self
+    #   else
+    #     raise 'No block or enum given. Use #new -> << -> #save for generating report later'
+    #   end
+    #   save(file)
+    # end
+
+    # def self.[](*args)
+    #   new.run(*args)
+    # end
+
+    # Save xlsx file with provided data
+    # @param [String] file File name the data to be serialized
+    def save(file)
+      done
+      begin
+        @package.serialize(file)
+      rescue Errno::EACCES => e
+        puts "#{file} is protected!"
+        file = file + ".tmp"
+        @package.serialize(file)
+      end
+    end
+
+    # Finalize document formatting after data collecting and before saving.
+    # @note Called during #save.
+    # @note Don't call twice. Don't call before all data provided.
+    def done
+      apply_width(sheet)
+      merge_same(sheet)
+      sheet.add_row(@totals) if @totals
+    end
+
+    # Axlsx sheet.
+    # @return [Axlsx::Worksheet]
+    def sheet
+      @sheet ||= init_sheet(sheet_name)
+    end
+
+    private
+
+    def columns
+      self.class.instance_eval { @columns }
+    end
+
+    def init_sheet(name = 'Sheet1')
+      sheet = @package.workbook.add_worksheet(:name => sheetify_name(name))
+      if self.respond_to? :title
+        if title.is_a? Array
+          title.each do |t|
+            sheet.add_row [t]
+          end
+        else
+          sheet.add_row [title]
+        end
+      end
+      if defined? groups
+        add_group_head sheet
+      else
+        add_head sheet, *columns.map{ |col| eval_name(col.name) }
+        sheet.rows.last.height = head_height if defined? head_height
+      end
+      if defined? numerate_columns
+        add_frozen_head sheet, *(1..(columns.length)).to_a
+      else
+        froze(sheet, sheet.rows.count)
+        auto_filter(sheet)
+      end
+      @header_rows = sheet.rows.count
+      sheet
+    end
+
+    def auto_filter(sheet)
+      sheet.auto_filter = Axlsx::cell_range(sheet.rows.last.cells, false)
+    end
+
+    def apply_width(sheet)
+      sheet.column_widths *columns.map(&:width).map { |width| width || default_column_width }
+    end
+
+    def merge_same(sheet)
+      columns.map(&:options).each_with_index do |ops, col_num|
+        next unless ops[:merge_same]
+        merged_style ||= sheet.styles.add_style(:alignment => { :vertical => :center })
+        col_char = column_num_to_name(col_num + 1)
+        last, start_row = nil, 0
+        sheet.rows.dup.each_with_index do |row, row_num|
+          next if row_num < @header_rows
+          col_value = row.cells[col_num].value
+          if last && last != col_value && (row_num - start_row) > 1
+            range = "#{col_char}#{start_row + 1}:#{col_char}#{row_num}"
+            sheet.merge_cells(range)
+            sheet[range].each { |c| c.style = merged_style }
+          end
+          if last != col_value
+            last = col_value
+            start_row = row_num
+          end
+        end
+        if last && (sheet.rows.length - start_row) > 1
+          range = "#{col_char}#{start_row + 1}:#{col_char}#{sheet.rows.length}"
+          sheet.merge_cells(range)
+          sheet[range].each { |c| c.style = merged_style }
+        end
+      end
+    end
+
+    def default_column_width
+      16
+    end
+
+    def add_group_head(sheet)
+      head_row = *columns.map{ |col| eval_name(col.name) }
+      groups.each { |g| head_row[g.start_index] = g.name }
+      add_head sheet, *head_row
+      group_row = sheet.rows.length
+      groups.map { |g| "#{column_num_to_name(g.start_index + 1)}#{group_row}:#{column_num_to_name(g.end_index + 1)}#{group_row}" }
+        .each { |rng| sheet.merge_cells(rng) }
+      sheet.rows.last.height = group_height if defined? group_height
+      add_head sheet, *columns.map{ |col| eval_name(col.name) }
+      sheet.rows.last.height = head_height if defined? head_height
+      names_row = sheet.rows.length
+      units = *columns.map(&:units)
+      has_units = !units.all?(&:nil?)
+      if has_units
+        add_head sheet, *units
+      end
+      units_row = sheet.rows.length
+      columns.map(&:options).each_with_index do |ops, index|
+        row_name = column_num_to_name(index + 1)
+        case
+        when ops[:units] && ops[:group]
+          nil
+        when ops[:group]
+          sheet.merge_cells("#{row_name}#{names_row}:#{row_name}#{units_row}") if has_units
+        when ops[:units]
+          sheet.merge_cells("#{row_name}#{group_row}:#{row_name}#{names_row}")
+        else
+          sheet.merge_cells("#{row_name}#{group_row}:#{row_name}#{units_row}")
+        end
+      end
+    end
+
+    def add_totals(row)
+      return unless total_actions
+      @totals ||= [nil] * columns.length
+      total_actions.each_with_index do |action, index|
+        case action
+          when String
+            @totals[index] = action
+          when :sum
+            if row[index]
+              @totals[index] ||= 0.0
+              @totals[index] += row[index]
+            end
+          when :count
+            if row[index]
+              @totals[index] ||= 0
+              @totals[index] += 1
+            end
+          when Proc
+            @totals[index] = action[row]
+        end
+      end
+    end
+
+    def total_actions
+      @total_actions ||=
+        columns.map(&:options).each do |ops|
+          ops[:total]
+        end
+    end
+
+    def eval_name(name)
+      name.is_a?(Proc) ? instance_exec(&name) : name
+    end
+
+    def sheetify_name(name)
+      name.gsub('/', '_')[0..30]
+    end
+
+    def add_head(sheet, *header)
+      row = nil
+      sheet.workbook.styles do |s|
+        head_style = s.add_style :border => { :style => :thin, :color => "00" },
+                                 :alignment => { :horizontal => :center,
+                                                 :vertical => :center ,
+                                                 :wrap_text => true}
+        row = sheet.add_row header, style: head_style
+      end
+      row
+    end
+
+    def add_frozen_head(sheet, *header)
+      row = add_head(sheet, *header)
+      froze(sheet, sheet.rows.count)
+      sheet.auto_filter = Axlsx::cell_range(row.cells, false)
+    end
+
+    def separate_sheet(sheet, sheet_name = 'Sheet2', &block)
+      sheet.workbook.add_worksheet(name: sheet_name) { |sheet| yield sheet }
+    end
+
+    def froze(sheet, num_rows = 2)
+      sheet.sheet_view do |vs|
+        vs.pane do |pane|
+          pane.state = :frozen
+          pane.y_split = num_rows
+        end
+      end
+    end
+
+    def row_options
+      options = {}
+      types = columns.map { |c| c.options[:type] }
+      options[:types] = types unless types.all?(&:nil?)
+      options
+    end
+  end
+end

data/lib/axlsx_report/column.rb

@@ -0,0 +1,55 @@
+module AxlsxReport
+  # Report's column representation
+  class Column
+    attr_reader :name, :callable, :options
+
+    # Creates new column
+    #
+    # @param [String] name Column name
+    # @param [Proc] callable Proc to calculate column value form given object
+    # @param [Hash] options ({}) Column parameters
+    # @option options [Integer] width: (16) column width
+    # @option options [Symbol] transform: report object method to be called after value calculation
+    # @option options [Symbol] with: method name of given object to be used to base for cell value calculation
+    # @option options [String] units: Units text to be added to the header in the column
+    # @option options [Symbol] type: axlsx type to be used in this column. One of Axlsx::Cell::CELL_TYPES
+    def initialize(name, callable, options = {})
+      @name, @callable, @options = name, callable, options
+    end
+
+    # Quick access to options
+    %i{width units}.each do |option|
+      define_method(option) do
+        @options[option]
+      end
+    end
+
+    # Calculates column value for given object
+    #
+    # @param [AxlsxReport::Base] report Report the value is calculated for
+    # @param [Any] obj Source object for column value
+    # @return Column value for given object.
+    def value(report, obj)
+      source = extract_source(obj)
+      return nil if source.nil?
+      value =
+        if callable.arity.zero?
+          source.instance_exec &callable
+        else
+          report.instance_exec source, &callable
+        end
+      transform = options[:transform]
+      value = report.send transform, value if transform
+      value
+    end
+
+    private
+
+      def extract_source(obj)
+        with = options[:with]
+        return obj unless with
+        return nil unless obj.respond_to?(with)
+        obj.send(with)
+      end
+  end
+end

data/lib/axlsx_report/column_name_conv.rb

@@ -0,0 +1,32 @@
+module AxlsxReport
+  module ColumnNameConv
+    extend self
+
+    # 'Z' => 25
+    # 'AA' => 26
+    def column_name_to_num(name)
+      num = 0
+      name.upcase.each_char do |c|
+        num *= 26 if num > 0
+        add = c.ord - "A".ord + 1
+        raise "Invalid symbol in Excel column name: '#{c}'" if add < 1 || add > 26
+        num += add
+      end
+      num - 1
+    end
+
+    # 1 => 'А'
+    # 26 => 'Z'
+    # 27 => 'AA'
+    # 28 => 'АB'
+    def column_num_to_name(num)
+      name = ""
+      while num > 0
+        nm = (num - 1) % 26
+        num = (num - 1) / 26
+        name << ("A".ord + nm).chr
+      end
+      name.reverse
+    end
+  end
+end

data/lib/axlsx_report/group.rb

@@ -0,0 +1,11 @@
+module AxlsxReport
+  class Group
+    attr_reader :name, :start_index
+    attr_accessor :end_index
+
+    def initialize(name, start_index)
+      @name = name
+      @start_index = start_index
+    end
+  end
+end

data/lib/axlsx_report/version.rb

@@ -0,0 +1,3 @@
+module AxlsxReport
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: axlsx_report
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alexey Volochnev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: axlsx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.13.2
+description: 
+email:
+- alexey.volochnev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- axlsx_report-0.1.0.gem
+- axlsx_report.gemspec
+- examples/base_report.rb
+- examples/group_report.rb
+- examples/lambda_report.rb
+- examples/width_report.rb
+- lib/axlsx_report.rb
+- lib/axlsx_report/base.rb
+- lib/axlsx_report/column.rb
+- lib/axlsx_report/column_name_conv.rb
+- lib/axlsx_report/group.rb
+- lib/axlsx_report/version.rb
+homepage: https://github.com/avolochnev/axlsx_report
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.5
+signing_key: 
+specification_version: 4
+summary: Declarative excel reports based on axlsx.
+test_files: []