rubyxls 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 565163dadd728164052abd601e382f4edc0f34fb
+  data.tar.gz: 8e2cf098733fbc299deab62a41eb9a85b81d33e2
+SHA512:
+  metadata.gz: 025c18aa1dbcd9e72bc8233ae09bc58a6c584097e0483248d9d2a2feeb045177ca10d4b86af5047ebf131552b1c6b04e0cd87dde5d0c04f7bc3e1efd03c3ae2a
+  data.tar.gz: 1303c010b7a56eb4a517525fba5a629d51a922c957bb76c038900a8726ff57d960cf62226d3ae4a691ccc36b3b957f6be0f6d209e7048670ccca63e56306b68c

data/.gitignore

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

data/.rspec

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

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at alexxander.frankel@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Alexander Frankel
+
+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,227 @@
+# Rubyxls
+
+Generate XLS files using ruby. Rubyxls provides a simple DSL :o express anything from simple ruby strings to complex Active Record models.
+Support for multi-sheet workbooks, chart generation, and formula based cells included.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rubyxls'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubyxls
+
+## Usage
+
+### Components
+After installing, Rubyxls is easy to use.
+
+Rubyxls has the same components of an actual excel spreadsheet, abstracting away the messy details.
+
+I like to think of the components in the following way:
+- **Report**: has_many workbooks (yes, a report can have many workbooks resulting in a zip file of all the workbooks)
+- **Workbook**: has_many sheets (when creating a new workbook, you are essentially creating a new xls file)
+- **Sheet**: has_many view models (tables)
+- **View Model (Table)**: this is where all of the data goes. More on ViewModels to come...
+- **Style Manager**: create re-usable styles to make sure your reports are beautiful and consistent.
+
+**Please don't be fooled by the has_many term listed above. This has nothing to do with ActiveRecord or any database relation. As a ruby/rails developer, I have just gotten in the habit of using this association terminology to describe any kind of relationship : )**
+
+In order to create your very own excel report, all you have to do is inherit each component's functionality that Rubyxls gives you.
+
+**Note: Rubyxls is built with the intention that you will include each of the listed components in your excel project, allowing each component to play nicely with each other.**
+
+#### Report
+```ruby
+class YourVeryOwnReport < Rubyxls::Report
+
+  def initialize(whatever_data_you_need)
+    @data = whatever_data_you_need
+    super()                               # Call #super with no parameters
+  end
+
+  private
+
+  def build_workbooks!
+    @workbooks << YourVeryOwnWorkbook.new(whatever_data_you_need)
+  end
+end
+```
+- **Inherit from Rubyxls::Report** - this will give you all the functionality a report needs to build itself.
+- **Call super() in #initialize** - this will create an instance variable `@workbooks` to hold all of the beautfiul workbooks you are about to create!
+- **#build_workbooks!** - append any workbooks that you create into `@workbooks` so that your report "has_many" workbooks just like the real excel!
+
+#### Workbook
+```ruby
+class YourVeryOwnWorkbook < Rubyxls::Workbook
+
+  def initialize(whatever_data_you_neeed)
+    @data = whatever_data_you_need
+    super(name: "your_very_own_workbook")   # Call #super passing in only a name parameter
+  end
+
+  private
+
+  def build_sheets!
+    @sheets << YourVeryOwnSheet.new(whatever_data_you_need)
+  end
+
+end
+```
+- **Inherit from Rubyxls::Workbook** - get all of that groovy (not the programming language) functionality that Rubyxls gives your Workbook.
+- **Call super() in #initialize passing in a "name" parameter** - this will create an instance variable `@sheets` to hold all of your sheets and will name the workbook you are creating.
+- **#build_sheets!** - append any sheets that you create into `@sheets` so that your workbook "has_many" sheets!
+
+#### Sheet
+```ruby
+class YourVeryOwnSheet < Rubyxls::Sheet
+
+  def initialize(whatever_data_you_need)
+    @data = whatever_data_you_need
+    super(sheet_name: "YourVeryOwnSheet")    # Call #super passing in only a sheet_name parameter
+  end
+
+  private
+
+  def build_cells
+    Rubyxls::Builders::CellBuilder.new(model_data_rows: YourVeryOwnViewModel.new(title: "Your Very Own View Model").data_rows, start_row: 1, start_column: "A").cells
+    .+ Rubyxls::Builders::CellBuilder.new(model_data_rows: AnotherViewModel.new(title: "Another View Model").data_rows, start_row: 4, start_column: "L").cells
+  end
+
+end
+```
+- **Inherit from Rubyxls::Sheet** - gotta get that sheet functionality
+- **Call super() in #initialize passing in a "name" parameter** - this will give your sheet a name
+- **#build_cells!** - this is the dumping ground for all of your data. The CellBuilder, which takes in a view model as a parameter will break apart your view models / tables into invidual
+cells and organize them properly. Don't forget to specify where on the sheet you would like your view models to be drawn using `start_row` and `start_column`!
+Behind the scenes, we are taking all of your modularized view models, breaking them apart into individual cells, throwing all of those cells into one LARGE pot and re-arranging them in the
+proper order. Cool, huh!
+
+#### ViewModel
+```ruby
+class YourVeryOwnViewModel < Rubyxls::ViewModel
+
+  def initialize(whatever_data_you_need)
+    @data = whatever_data_you_need
+    super()                             # Call #super passing in no parameters
+  end
+
+  private
+
+  def build_data_rows!
+    @data_rows << [
+                   { value: "Title Row", style: [:bold] }
+                  ]
+  end
+
+end
+```
+- **Inherit from Rubyxls::ViewModel**
+- **Call super() in #initialize passing**
+- **#build_data_rows!** - this is where you decide what data goes into the workbook and how it looks. Let's break it down by describing the ruby version of each excel component that makes up a row.
+  ```
+  | Ruby  | Excel | Desciption                                             |
+  | -----  -------  ------------------------------------------------------ |
+  | Array | Row   | Each array has lots of individual cells or ruby hashes |
+  | Hash  | Cell  | Each cell has a value and a style                      |
+  ```
+
+  `@data_rows` starts as an empty array that is defined when you call `super()` in the initialize method. The whole idea behind the View Model is to populate `@data_rows` with ruby arrays, each
+  representing a row in excel. Each ruby array is filled with ruby hashes, representing an individual cell.
+
+  Each individual cell is structured as follows:
+  ```ruby
+  { value: <any value>, style: [<list of styles to apply to this cell>] }
+  ```
+  A list of default styles is provided below!
+
+### Styling
+#### Default Styles
+- :bold
+- :italic
+- :underline
+- :strike
+- :indent
+- :left_align
+- :right_align
+- :center_align
+- :top_align
+- :bottom_align
+- :middle_align
+- :border_right
+- :boder_left
+- :boder_top
+- :boder_bottom
+- :boder_all
+- :number
+- :decimal
+- :date
+- :time
+- :currency
+- :currency_precision
+- :percent
+- :wrap_text
+
+#### Custom Styles
+``` ruby
+class YourVeryOwnCustomStyleManager < Rubyxls::StyleManager
+
+  GREY = 'CCCCCC'
+
+  def initialize
+    super                       # Call super
+  end
+
+  private
+
+  def initialize_base_styles!
+    define_style(style: :medium, attributes: { sz: 12 })
+    define_style(style: :large, attributes: { sz: 14 })
+    define_style(style: :total_row, attributes: { b: true, bg_color: GREY })
+    super
+  end
+
+end
+```
+- **Inherit from Rubyxls::StyleManager**
+- **Call super in #initialize passing** - in order to get all of those default styles that Rubyxls provides.
+- **#initialize_base_styles!** - define your own styles according the the excel specification. Each style only needs a set of attributes.
+
+Now you can apply your newly defined styles inside of any sheet.
+
+**Note: in order to use user-defined styles, you must specify which style manager you would like to use when creating your sheet.**
+```ruby
+class YourVeryOwnSheet
+
+  def initialize(data)
+    @data = data
+    super(sheet_name: "YourVeryOwnSheet", style_manager: YourVeryOwnCustomStyleManager.new)
+  end
+
+end
+```
+Now you will have access to your user-defined styles and the default styles that ship with Rubyxls!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/alexanderfrankel/rubyxls. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## 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,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rubyxls"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/generate_default

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rubyxls"
+
+default_report = Rubyxls.generate_default_report
+Rubyxls.write_report_to_tmp(default_report)
+Rubyxls.open(default_report)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,8 @@
+machine:
+
+  timezone:
+    America/New_York
+
+  ruby:
+    version:
+      2.3.0

data/lib/rubyxls.rb

@@ -0,0 +1,43 @@
+module Rubyxls
+
+  def self.generate_default_report
+    Report.new
+  end
+
+  def self.write_report_to_tmp(report)
+    file_path = report_tmp_file_path(report)
+    FileUtils.mkdir_p(tmp_dir_path) unless File.directory?(tmp_dir_path)
+    File.delete(file_path) if File.exist?(file_path)
+    File.open(file_path, 'w') do |file|
+      file << report.download!.read
+    end
+  end
+
+  def self.open(report)
+    `open "#{report_tmp_file_path(report)}"`
+  end
+
+  private
+
+  def self.tmp_dir_path
+    File.expand_path('../../tmp', __FILE__)
+  end
+
+  def self.report_tmp_file_path(report)
+    tmp_dir_path + "/#{report.file_name}.#{report.file_extension}"
+  end
+
+end
+
+require 'rubyxls/version'
+
+require 'rubyxls/report'
+require 'rubyxls/sheet'
+require 'rubyxls/style_manager'
+require 'rubyxls/view_model'
+require 'rubyxls/workbook'
+
+require 'rubyxls/builders/cell_builder'
+require 'rubyxls/builders/chart_builder'
+require 'rubyxls/builders/formula_builder'
+require 'rubyxls/builders/row_builder'

data/lib/rubyxls/builders/cell_builder.rb

@@ -0,0 +1,39 @@
+module Rubyxls
+  module Builders
+    class CellBuilder
+
+      attr_reader :cells
+
+      def initialize(**opts)
+        @model_data_rows = opts.fetch(:model_data_rows)
+        @start_row = opts.fetch(:start_row, 1)
+        @start_column = opts.fetch(:start_column, "A")
+        @cells = []
+        build_cells!
+      end
+
+      private
+
+      def build_cells!
+        assign_row_column!
+        @cells = @model_data_rows.flatten
+      end
+
+      def assign_row_column!
+        @model_data_rows.each_with_index do |data_row, table_row_index|
+          data_row.each_with_index do |data_cell, table_column_index|
+            data_cell[:row] = @start_row + table_row_index
+            data_cell[:column] = retrieve_cell_column_letter(@start_column, table_column_index)
+          end
+        end
+      end
+
+      def retrieve_cell_column_letter(start_column, table_column_index)
+         cell_column = start_column.clone
+         table_column_index.times { cell_column.next! }
+         cell_column
+      end
+
+    end
+  end
+end

data/lib/rubyxls/builders/chart_builder.rb

@@ -0,0 +1,39 @@
+require 'axlsx'
+
+module Rubyxls
+  module Builders
+    class ChartBuilder
+
+      attr_reader :type
+      attr_reader :start_at
+      attr_reader :end_at
+      attr_reader :title
+      attr_reader :rot_x
+      attr_reader :rot_y
+      attr_reader :show_legend
+      attr_reader :bar_dir
+      attr_reader :cat_axis_title
+      attr_reader :val_axis_title
+      attr_reader :cat_axis_gridlines
+      attr_reader :val_axis_gridlines
+      attr_reader :series
+
+      def initialize(**opts)
+        @type = opts.fetch(:type, Axlsx::Bar3DChart)
+        @start_at = opts.fetch(:start_at, "A1")
+        @end_at = opts.fetch(:end_at, "A1")
+        @title = opts.fetch(:title, " ")
+        @rot_x = opts.fetch(:rot_x, 30)
+        @rot_y = opts.fetch(:rot_y, 20)
+        @show_legend = opts.fetch(:show_legend, false)
+        @bar_dir = opts.fetch(:bar_dir, :col)
+        @cat_axis_title = opts.fetch(:cat_axis_title, " ")
+        @val_axis_title = opts.fetch(:val_axis_title, " ")
+        @cat_axis_gridlines = opts.fetch(:cat_axis_gridlines, false)
+        @val_axis_gridlines = opts.fetch(:val_axis_gridlines, false)
+        @series = opts.fetch(:series, [])
+      end
+
+    end
+  end
+end

data/lib/rubyxls/builders/formula_builder.rb

@@ -0,0 +1,60 @@
+module Rubyxls
+  module Builders
+    class FormulaBuilder
+
+      attr_reader :cells
+
+      def initialize(**opts)
+        @value = opts.fetch(:value, nil)
+        @style = opts.fetch(:style, [:default])
+        @width = opts.fetch(:width, nil)
+        @height = opts.fetch(:height, nil)
+        @data_validation = opts.fetch(:data_validation, nil)
+        @merge = opts.fetch(:merge, nil)
+        @fill = opts.fetch(:fill, :right)
+        @num_cells = opts.fetch(:num_cells, nil)
+        @row_index = opts.fetch(:row_index, nil)
+        @cells = []
+
+        fill_right! if @fill == :right
+        fill_down! if @fill == :down
+        fill_all! if @fill == :all
+      end
+
+      private
+
+      def fill_right!
+        raise "Num cells cannot be nil when filling right for formula: #{@value}!" if @num_cells.nil?
+        @num_cells.times do
+          add_cell!
+          shift_value_right!
+        end
+      end
+
+      def fill_down!
+        raise "Row index cannot be nil when filling down for formula: #{@value}!" if @row_index.nil?
+        shift_value_down!
+        add_cell!
+      end
+
+      def fill_all!
+        raise "Both num cells & row index cannot be nil when filling all for formula: #{@value}!" if @num_cells.nil? || @row_index.nil?
+        shift_value_down!
+        fill_right!
+      end
+
+      def add_cell!
+        @cells << { value: @value.nil? ? nil : @value.clone, style: @style, width: @width, height: @height, data_validation: @data_validation, merge: @merge }
+      end
+
+      def shift_value_right!
+        @value.nil? ? nil : @value.gsub!(/(?<![\$A-Z])[A-Z]+(?=[\$\d])/) { |column| column.next }
+      end
+
+      def shift_value_down!
+        @value.nil? ? nil : @value.gsub!(/(?<=[A-Z])[0-9]+/) { |row| row.to_i + @row_index }
+      end
+
+    end
+  end
+end

data/lib/rubyxls/builders/row_builder.rb

@@ -0,0 +1,50 @@
+module Rubyxls
+  module Builders
+    class RowBuilder
+
+      attr_reader :rows
+
+      def initialize(cells)
+        @cells = cells
+        @bottom_row_bound = 0
+        @right_column_bound = 0
+        expand_bottom_row_bound
+        expand_right_column_bound
+        @rows = Array.new(@bottom_row_bound) { Array.new(@right_column_bound) { { value: nil, style: [] } } }
+        build_rows!
+      end
+
+      private
+
+      def expand_bottom_row_bound
+        @cells.each do |cell|
+          @bottom_row_bound = cell[:row] if cell[:row] > @bottom_row_bound
+        end
+      end
+
+      def expand_right_column_bound
+        @cells.each do |cell|
+          @right_column_bound = convert_cell_column_to_integer(cell[:column]) if convert_cell_column_to_integer(cell[:column]) > @right_column_bound
+        end
+      end
+
+      def convert_cell_column_to_integer(cell_column)
+        offset = "A".ord - 1
+        cell_column.chars.inject(0) { |sum,char| sum * 26 + char.ord - offset }
+      end
+
+      def build_rows!
+        @cells.each { |cell| @rows[retrieve_cell_row_index(cell[:row])][retrieve_cell_column_index(cell[:column])] = cell }
+      end
+
+      def retrieve_cell_row_index(cell_row)
+        cell_row - 1
+      end
+
+      def retrieve_cell_column_index(cell_column)
+        convert_cell_column_to_integer(cell_column) - 1
+      end
+
+    end
+  end
+end

data/lib/rubyxls/report.rb

@@ -0,0 +1,48 @@
+module Rubyxls
+  class Report
+
+    attr_reader :workbooks
+    attr_reader :file_name
+
+    def initialize
+      @workbooks = []
+      @file_name = 'rubyxls'
+      build_workbooks!
+    end
+
+    def download!
+      if @workbooks.size == 1
+        @workbooks.first.to_stream
+      else
+        stream = StringIO.new
+        zipfile = Zip::File.new(stream, true, true)
+        @workbooks.each do |workbook|
+          zipfile.get_output_stream(workbook.filename) { |zipstream| IO.copy_stream(workbook.to_stream, zipstream) }
+        end
+        zipfile.write_buffer(stream)
+        zipfile.glob('*', &:clean_up)
+        stream.rewind
+        stream
+      end
+    end
+
+    def file_extension
+      @workbooks.size > 1 ? :zip : :xlsx
+    end
+
+    def content_type
+      if file_extension == :xlsx
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+      elsif file_extension == :zip
+        'application/zip'
+      end
+    end
+
+    private
+
+    def build_workbooks!
+      @workbooks << Rubyxls::Workbook.new
+    end
+
+  end
+end

data/lib/rubyxls/sheet.rb

@@ -0,0 +1,82 @@
+module Rubyxls
+  class Sheet
+
+    FIT_TO_WIDTH = 1
+    ORIENTATION = :landscape
+    GRID_LINES = false
+    PAGE_MARGIN_TOP = 0.3
+    PAGE_MARGIN_LEFT = 0.3
+    PAGE_MARGIN_BOTTOM = 0.3
+    PAGE_MARGIN_RIGHT = 0.3
+    HEADER = 0.0
+    FOOTER = 0.0
+    LETTER_PAPER_SIZE = 1
+
+    attr_reader :sheet_name
+
+    def initialize(**opts)
+      @sheet_name = opts.fetch(:sheet_name, "Default Sheet")
+      @style_manager = opts.fetch(:style_manager, Rubyxls::StyleManager.new)
+      @paper_size = opts.fetch(:paper_size, LETTER_PAPER_SIZE)
+    end
+
+    def build_options(*taken_names)
+      { page_setup: build_page_setup,
+        print_options: build_print_options,
+        page_margins: build_page_margins,
+        name: unique_sheet_name(sanitize_sheet_name(@sheet_name), taken_names) }
+    end
+
+    def build_rows
+      Rubyxls::Builders::RowBuilder.new(build_cells).rows.each do |row|
+        row.each do |cell|
+          cell[:style] = @style_manager.retrieve_style_attributes(cell[:style])
+        end
+      end
+    end
+
+    def build_charts
+      []
+    end
+
+    def build_width_normalization
+      {}
+    end
+
+    private
+
+    def build_page_setup
+      { fit_to_width: FIT_TO_WIDTH,
+        orientation: ORIENTATION,
+        paper_size: @paper_size }
+    end
+
+    def build_print_options
+      { grid_lines: GRID_LINES }
+    end
+
+    def build_page_margins
+      { top: PAGE_MARGIN_TOP,
+        left: PAGE_MARGIN_LEFT,
+        bottom: PAGE_MARGIN_BOTTOM,
+        right: PAGE_MARGIN_RIGHT,
+        header: HEADER,
+        footer: FOOTER }
+    end
+
+    def build_cells
+      Rubyxls::Builders::CellBuilder.new(model_data_rows: Rubyxls::ViewModel.new(title_row: true, header_row: true, additional_rows: 1, total_row: true).data_rows, start_row: 2, start_column: "B").cells
+    end
+
+    def sanitize_sheet_name(sheet_name)
+      sheet_name.gsub(/[:\[\]\/\\\*\?]/, '-')
+    end
+
+    def unique_sheet_name(sheet_name, taken_names, index=1)
+      return sheet_name[0, 31] unless taken_names.include?(sheet_name[0, 31])
+      sheet_name = "#{sheet_name[0, 29 - index.to_s.length]}(#{index})"
+      unique_sheet_name(sheet_name, taken_names, index + 1)
+    end
+
+  end
+end

data/lib/rubyxls/style_manager.rb

@@ -0,0 +1,62 @@
+module Rubyxls
+  class StyleManager
+
+    def initialize(opts={})
+      @styles = {}
+      initialize_default_style!
+      initialize_base_styles!
+    end
+
+    def retrieve_style_attributes(styles)
+      styles = [] if styles.nil?
+      styles.each_with_object(@styles[:default].clone) do |style, combined_styles_hash|
+        raise("The style :#{style} has not been defined! Please define or create a new type of Style in the styles directory!") if @styles[style].nil?
+        combined_styles_hash.merge!(@styles[style])
+      end
+    end
+
+    private
+
+    def initialize_default_style!
+      define_style(style: :default, attributes: { alignment: { horizontal: :left, wrap_text: false, vertical: :bottom }, font_name: 'Arial', sz: 10, border: { style: :none, color: "000000" } })
+    end
+
+    def initialize_base_styles!
+      define_style(style: :bold, attributes: { b: true })
+      define_style(style: :italic, attributes: { i: true })
+      define_style(style: :underline, attributes: { u: true })
+      define_style(style: :strike, attributes: { strike: true })
+
+      define_style(style: :indent, attributes: { alignment: { indent: 1 } })
+
+      define_style(style: :left_align, attributes: { alignment: { horizontal: :left } })
+      define_style(style: :right_align, attributes: { alignment: { horizontal: :right } })
+      define_style(style: :center_align, attributes: { alignment: { horizontal: :center } })
+
+      define_style(style: :top_align, attributes: { alignment: { vertical: :top } })
+      define_style(style: :bottom_align, attributes: { alignment: { vertical: :bottom } })
+      define_style(style: :middle_align, attributes: { alignment: { vertical: :center } })
+
+      define_style(style: :border_right, attributes: { border_right: { style: :thin } })
+      define_style(style: :border_left, attributes: { border_left: { style: :thin } })
+      define_style(style: :border_top, attributes: { border_top: { style: :thin } })
+      define_style(style: :border_bottom, attributes: { border_bottom: { style: :thin } })
+      define_style(style: :border_all, attributes: { border_right: { style: :thin }, border_left: { style: :thin }, border_top: { style: :thin }, border_bottom: { style: :thin } })
+
+      define_style(style: :number, attributes: { format_code: '#,##0_ ;(#,##0)' })
+      define_style(style: :decimal, attributes: { format_code: '#,##0.00_ ;(#,##0.00)' })
+      define_style(style: :date, attributes: { format_code: 'MM/D/YY' })
+      define_style(style: :time, attributes: { format_code: '[$-409]h:mm AM/PM;@' })
+      define_style(style: :currency, attributes: { format_code: '$#,##0;($#,##0)' })
+      define_style(style: :currency_precision, attributes: { format_code: '$#,##0.00;($#,##0.00)' })
+      define_style(style: :percent, attributes: { format_code: '0.00%;(0.00%)' })
+
+      define_style(style: :wrap_text, attributes: { alignment: { wrap_text: true } })
+    end
+
+    def define_style(style:, attributes: {})
+      @styles[style] = attributes if @styles[style].nil?
+    end
+
+  end
+end

data/lib/rubyxls/version.rb

@@ -0,0 +1,3 @@
+module Rubyxls
+  VERSION = "1.0.0"
+end

data/lib/rubyxls/view_model.rb

@@ -0,0 +1,58 @@
+module Rubyxls
+  class ViewModel
+
+    attr_reader :data_rows
+
+    def initialize(**opts)
+      @data_rows = []
+      @data_rows_count = opts.fetch(:rows_count, nil)
+
+      build_title_row!
+      build_header_row!
+      build_data_rows!
+      build_additional_rows! unless @data_rows_count.nil?
+      build_total_row!
+    end
+
+    private
+
+    def build_title_row!
+      []
+    end
+
+    def build_header_row!
+      []
+    end
+
+    def build_data_rows!
+      []
+    end
+
+    def build_additional_row!
+      []
+    end
+
+    def build_total_row!
+      []
+    end
+
+    def build_additional_rows!
+      until @data_rows.size == @data_rows_count do
+        build_additional_row!
+      end
+    end
+
+    def add_empty_cell(*style)
+      { value: nil, style: style }
+    end
+
+    def limit_data_to_data_rows_count(data)
+      @data_rows_count.nil? ? data : data[0...calculate_data_rows_remaining]
+    end
+
+    def calculate_data_rows_remaining
+      @data_rows_count - @data_rows.size
+    end
+
+  end
+end

data/lib/rubyxls/workbook.rb

@@ -0,0 +1,129 @@
+require 'delegate'
+
+module Rubyxls
+  class Workbook < SimpleDelegator
+
+    attr_reader :sheets
+
+    def initialize(**opts)
+      @package = Axlsx::Package.new
+      @package.use_shared_strings = true
+      @name = opts.fetch(:name, "default_workbook")
+      @style_codes = {}
+      @sheets = []
+
+      super(@package.workbook)
+      build_sheets!
+      add_sheets!
+    end
+
+    def to_stream
+      @package.to_stream
+    end
+
+    def filename
+      "#{@name}.xlsx"
+    end
+
+    private
+
+    def build_sheets!
+      @sheets << Rubyxls::Sheet.new
+    end
+
+    def add_sheets!
+      @sheets.each do |sheet|
+        @data_validations = {}
+        add_sheet(sheet.build_options(*workbook_sheet_names))
+        add_rows(sheet.build_rows)
+        add_data_validations
+        add_charts(sheet.build_charts)
+        add_width_normalization(sheet.build_width_normalization)
+      end
+    end
+
+    def add_sheet(options)
+      add_worksheet(options) do |sheet|
+        sheet.sheet_view.show_grid_lines = false
+        sheet.page_setup.fit_to(width: 1, height: 999)
+        @sheet = sheet
+      end
+    end
+
+    def add_rows(rows)
+      rows.each do |row|
+        values = []
+        widths = []
+        styles = []
+        height = nil
+        row.each do |cell|
+          values << cell[:value]
+          widths << cell[:width]
+          styles << retrieve_style_code(cell[:style])
+          height = cell[:height] if cell[:height]
+          merge_cell(cell) if cell[:merge]
+          @data_validations["#{cell[:column]}#{cell[:row]}"] = cell[:data_validation] if cell[:data_validation]
+        end
+        @sheet.add_row(values, { style: styles, widths: widths, height: height })
+      end
+    end
+
+    def retrieve_style_code(style_attributes)
+      hash_attributes = style_attributes.clone
+      @style_codes[hash_attributes] ||= styles.add_style(style_attributes)
+    end
+
+    def merge_cell(cell)
+      case cell[:merge]
+      when :right
+        @sheet.merge_cells("#{cell[:column]}#{cell[:row]}:#{cell[:column].next}#{cell[:row]}")
+      when :down
+        @sheet.merge_cells("#{cell[:column]}#{cell[:row]}:#{cell[:column]}#{cell[:row] + 1}")
+      end
+    end
+
+    def add_data_validations
+      @data_validations.each do |data_validation_cell, data_validation_values|
+        start_column = "A"
+        end_column = start_column.clone
+        (data_validation_values.size - 1).times { end_column.next! }
+        @sheet.add_row(data_validation_values, { style: Array.new(data_validation_values.size, retrieve_style_code({ fg_color: "FFFFFF", bg_color: "FFFFFF" })) })
+        @sheet.add_data_validation(data_validation_cell, { type: :list, formula1: "$#{start_column}$#{@sheet.rows.count}:$#{end_column}$#{@sheet.rows.count}", showDropdown: false })
+      end
+    end
+
+    def add_charts(charts)
+      charts.each do |chart|
+        @sheet.add_chart(chart.type, start_at: chart.start_at, end_at: chart.end_at, rotX: chart.rot_x, rotY: chart.rot_y) do |added_chart|
+          added_chart.title = chart.title
+          added_chart.bar_dir = chart.bar_dir if added_chart.respond_to?(:bar_dir)
+          added_chart.show_legend = chart.show_legend
+          added_chart.catAxis.title = chart.cat_axis_title if added_chart.respond_to?(:catAxis)
+          added_chart.valAxis.title = chart.val_axis_title if added_chart.respond_to?(:valAxis)
+          added_chart.catAxis.gridlines = chart.cat_axis_gridlines if added_chart.respond_to?(:catAxis)
+          added_chart.valAxis.gridlines = chart.val_axis_gridlines if added_chart.respond_to?(:valAxis)
+          chart.series.each do |series|
+            added_chart.add_series(data: @sheet[series[:data]], labels: @sheet[series[:labels]], colors: series[:colors])
+          end
+        end
+      end
+    end
+
+    def add_width_normalization(custom_widths: [], default_width: nil)
+      if @sheet.rows.size > 0
+        row_values = Array.new(@sheet.cols.count, nil)
+        row_widths = Array.new(@sheet.cols.count, default_width)
+        custom_widths.reverse.each do |custom_width|
+          row_widths.unshift(custom_width)
+          row_widths.pop
+        end
+        @sheet.add_row(row_values, { widths: row_widths })
+      end
+    end
+
+    def workbook_sheet_names
+      @package.workbook.worksheets.map(&:name)
+    end
+
+  end
+end

data/rubyxls.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubyxls/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubyxls"
+  spec.version       = Rubyxls::VERSION
+  spec.authors       = ["Alexander Frankel"]
+  spec.email         = ["alexxander.frankel@gmail.com"]
+
+  spec.summary       = %q{A simple DSL for generating XLS files in plain-old ruby.}
+  spec.description   = %q{Generate XLS files using ruby. Rubyxls provides a simple DSL to
+                          express anything from simple ruby strings to complex Active Record models.
+                          Support for multi-sheet workbooks, chart generation, and formula based cells included.}
+  spec.homepage      = "https://github.com/alexanderfrankel/rubyxls"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "axlsx", "~> 2.0.1"
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: rubyxls
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexander Frankel
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: axlsx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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.1
+description: |-
+  Generate XLS files using ruby. Rubyxls provides a simple DSL to
+                            express anything from simple ruby strings to complex Active Record models.
+                            Support for multi-sheet workbooks, chart generation, and formula based cells included.
+email:
+- alexxander.frankel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/generate_default
+- bin/setup
+- circle.yml
+- lib/rubyxls.rb
+- lib/rubyxls/builders/cell_builder.rb
+- lib/rubyxls/builders/chart_builder.rb
+- lib/rubyxls/builders/formula_builder.rb
+- lib/rubyxls/builders/row_builder.rb
+- lib/rubyxls/report.rb
+- lib/rubyxls/sheet.rb
+- lib/rubyxls/style_manager.rb
+- lib/rubyxls/version.rb
+- lib/rubyxls/view_model.rb
+- lib/rubyxls/workbook.rb
+- rubyxls.gemspec
+homepage: https://github.com/alexanderfrankel/rubyxls
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A simple DSL for generating XLS files in plain-old ruby.
+test_files: []
+has_rdoc: