spreadsheet_architect 1.0.0

data/README.md

@@ -0,0 +1,136 @@
+# Spreadsheet Architect
+
+Spreadsheet Architect lets you turn any activerecord relation or plain ruby class object into a XLSX, ODS, or CSV spreadsheets. Generates columns from model activerecord column_names or from an array of ruby methods.
+
+Spreadsheet Architect adds the following methods to your class:
+```ruby
+# Plain Ruby
+Post.to_xlsx(data: posts_array)
+Post.to_ods(data: posts_array)
+Post.to_csv(data: posts_array)
+
+# Rails
+Post.order(name: :asc).where(published: true).to_xlsx
+Post.order(name: :asc).where(published: true).to_ods
+Post.order(name: :asc).where(published: true).to_csv
+```
+
+
+# Install
+```ruby
+gem install spreadsheet_architect
+```
+
+
+# Setup
+
+### Model
+```ruby
+class Post < ActiveRecord::Base #activerecord not required
+  include SpreadsheetArchitect
+
+  belongs_to :author
+
+  #optional for activerecord classes, defaults to the models column_names
+  def self.spreadsheet_columns
+    #[[Label, Method/Statement to Call on each Instance]....]
+    [['Title', :title],['Content', 'content'],['Author','author.name rescue nil',['Published?', "(published ? 'Yes' : 'No')"]]]
+
+    # OR just humanize the method to use as the label ex. "Title", "Content", "Author Name", "Published"
+    [:title, 'content', 'author.name rescue nil', :published]
+
+    # OR a Combination of Both
+    [:title, :content, ['Author','author.name rescue nil'], :published]
+  end
+end
+```
+
+# Usage
+
+### Method 1: Controller for a Rails Model
+```ruby
+class PostsController < ActionController::Base
+  def index
+    @posts = Post.order(published_at: :asc)
+  
+    respond_to do |format|
+      format.html
+      format.xlsx { render xlsx: @posts.to_xlsx, filename: "posts.xlsx" }
+      format.ods { render ods: @posts.to_ods, filename: "posts.ods" }
+      format.csv { render csv: @posts.to_csv, filename: "posts.csv" }
+    end
+  end
+end
+```
+
+### Method 2: Controller for a Plain Ruby Model
+```ruby
+class PostsController < ActionController::Base
+  def index
+    posts_array = [Post.new, Post.new, Post.new]
+
+    respond_to do |format|
+      format.html
+      format.xlsx { render xlsx: Post.to_xlsx(data: posts_array), filename: "posts.xlsx" }
+      format.ods { render ods: Post.to_ods(data: posts_array), filename: "posts.ods" }
+      format.csv { render csv: Post.to_csv(data: posts_array), filename: "posts.csv" }
+    end
+  end
+end
+```
+
+### Method 3: Save to a file manually
+```ruby
+File.open('path/to/file.xlsx') do |f|
+  f.write{ Post.order(published_at: :asc).to_xlsx }
+end
+File.open('path/to/file.ods') do |f|
+  f.write{ Post.order(published_at: :asc).to_ods }
+end
+File.open('path/to/file.csv') do |f|
+  f.write{ Post.order(published_at: :asc).to_csv }
+end
+```
+
+
+# Method Options
+
+### to_xlsx, to_ods, to_csv
+**data** - *Array* - Mainly for Plain Ruby objects pass in an array of instances. Optional for ActiveRecord relations, you can just chain the method to the end of your relation.
+
+**headers** - *Boolean* - Default: true - Pass in false if you do not want a header row.
+
+**spreadsheet_columns** - *Array* - A string array of attributes, methods, or ruby statements to be executed on each instance. Use this to override the models spreadsheet_columns/column_names method for one time.
+
+### to_xlsx
+**sheet_name** - *String*
+
+**header_style** - *Hash* - Default: `{bg_color: "AAAAAA", fg_color: "FFFFFF", alignment: { horizontal: :center }, bold: true}`
+  
+**row_style** - Hash
+
+### to_ods
+**sheet_name** - *String*
+
+**header_style** - *Hash* - Default: {bold: true} - Note: Currently only supports bold & fg_color style options
+
+**row_style** - *Hash*
+
+### to_csv
+Only the generic options
+
+
+# Style Options
+**bg_color** - *6 Digit Hex Color without the # Symbol* - Ex. "AAAAAAA" 
+
+**fg_color** - *Text Color - 6 Digit Hex Color without the # Symbol* - Ex. "0000000" 
+
+**alignment** - *Hash* - Ex. {horizontal: :right, vertical: :top}
+
+**bold** - *Boolean*
+
+
+# Credits
+Created by Weston Ganger - @westonganger
+
+Heavily influenced by the dead gem `acts_as_xlsx` by @randym but adapted to work for more spreadsheet types and plain ruby models.

data/Rakefile

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/spreadsheet_architect/version.rb')
+require 'bundler/gem_tasks'
+
+task :test do 
+  require 'rake/testtask'
+  Rake::TestTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/tc_*.rb']
+    t.verbose = true
+  end
+end
+
+task release: :build do
+  system "gem push spreadsheet_architect-#{SpreadsheetArchitect::VERSION}.gem"
+end
+
+task default: :test

data/lib/spreadsheet_architect.rb

@@ -0,0 +1,170 @@
+require 'spreadsheet_architect/set_mime_types'
+require 'spreadsheet_architect/action_controller_renderers'
+require 'axlsx'
+require 'spreadsheet_architect/axlsx_column_width_patch'
+require 'odf/spreadsheet'
+require 'csv'
+
+module SpreadsheetArchitect
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  module ClassMethods
+    def sa_str_humanize(str, capitalize = true)
+      str = str.sub(/\A_+/, '').sub(/_id\z/, '').gsub(/[_\.]/,' ').sub(' rescue nil','')
+      if capitalize
+        str = str.gsub(/(\A|\ )\w/){|x| x.upcase}
+      end
+      str
+    end
+
+    def sa_get_options(options={})
+      if self.ancestors.include?(ActiveRecord::Base) && !self.respond_to?(:spreadsheet_columns) && !options[:spreadsheet_columns]
+        headers = self.column_names.map{|x| x.humanize}
+        columns = self.column_names.map{|x| x.to_s}
+      elsif options[:spreadsheet_columns] || self.respond_to?(:spreadsheet_columns)
+        headers = []
+        columns = []
+
+        array = options[:spreadsheet_columns] || self.spreadsheet_columns || []
+        array.each do |x|
+          if x.is_a?(Array)
+            headers.push x[0].to_s
+            columns.push x[1].to_s
+          else
+            headers.push sa_str_humanize(x.to_s)
+            columns.push x.to_s
+          end
+        end
+      else
+        headers = []
+        columns = []
+      end
+
+      headers = (options[:headers] == false ? false : headers)
+
+      if options[:header_style]
+        header_style = options[:header_style]
+      elsif options[:header_style] == false
+        header_style = false
+      elsif options[:row_style]
+        header_style = options[:row_style]
+      else
+        header_style = {bg_color: "AAAAAA", fg_color: "FFFFFF", alignment: { horizontal: :center }, bold: true}
+      end
+
+      row_style = options[:row_style]
+
+      sheet_name = options[:sheet_name] || self.name
+      
+      if options[:data]
+        data = options[:data].to_a
+      elsif self.ancestors.include?(ActiveRecord::Base)
+        data = where(options[:where]).order(options[:order]).to_a
+      else
+        # object must have a to_a method 
+        data = self.to_a
+      end
+
+      types = (options[:types] || []).flatten
+
+      return {headers: headers, columns: columns, header_style: header_style, row_style: row_style, types: types, sheet_name: sheet_name, data: data}
+    end
+
+    def sa_get_row_data(the_columns=[], instance)
+      row_data = []
+      the_columns.each do |col|
+        col.split('.').each_with_index do |x,i| 
+          if i == 0
+            col = instance.instance_eval(x)
+          else
+            col = col.instance_eval(x)
+          end
+        end
+        row_data.push col
+      end
+      return row_data
+    end
+
+    def to_csv(opts={})
+      options = sa_get_options(opts)
+
+      CSV.generate do |csv|
+        csv << options[:headers] if options[:headers]
+        
+        options[:data].each do |x|
+          csv << sa_get_row_data(options[:columns], x)
+        end
+      end
+    end
+
+    def to_ods(opts={})
+      options = sa_get_options(opts)
+
+      spreadsheet = ODF::Spreadsheet.new
+
+      spreadsheet.office_style :header_style, family: :cell do
+        if options[:header_style]
+          if options[:header_style][:bold]
+            property :text, 'font-weight': :bold
+            property :text, 'align': :center
+          end
+          if options[:header_style][:fg_color] && opts[:header_style] && opts[:header_style][:fg_color] #temporary
+            property :text, 'color': "##{options[:header_style][:fg_color]}"
+          end
+        end
+      end
+      spreadsheet.office_style :row_style, family: :cell do
+        if options[:row_style]
+          if options[:row_style][:bold]
+            property :text, 'font-weight': :bold
+          end
+          if options[:row_style][:fg_color]
+            property :text, 'color': "##{options[:header_style][:fg_color]}"
+          end
+        end
+      end
+
+      this_class = self
+      spreadsheet.table options[:sheet_name] do 
+        if options[:headers]
+          row do
+            options[:headers].each do |header|
+              cell header, style: (:header_style if options[:header_style])
+            end
+          end
+        end
+        options[:data].each do |x|
+          row do 
+            this_class.sa_get_row_data(options[:columns], x).each do |y|
+              cell y, style: (:row_style if options[:row_style])
+            end
+          end
+        end
+      end
+
+      return spreadsheet.bytes
+    end
+
+    def to_xlsx(opts={})
+      options = sa_get_options(opts)
+      
+      package = opts[:package] || Axlsx::Package.new
+
+      return package if options[:data].empty?
+
+      package.workbook.add_worksheet(name: options[:sheet_name]) do |sheet|
+        if options[:headers]
+          sheet.add_row options[:headers], style: (package.workbook.styles.add_style(options[:header_style]) if options[:header_style])
+        end
+        
+        options[:data].each do |x|
+          sheet.add_row sa_get_row_data(options[:columns], x), style: (package.workbook.styles.add_style(options[:row_style]) if options[:row_style]), types: options[:types]
+        end
+      end
+
+      return package.to_stream.read
+    end
+  end
+end

data/lib/spreadsheet_architect/action_controller_renderers.rb

@@ -0,0 +1,13 @@
+if defined? ActionController
+  ActionController::Renderers.add :xlsx do |data, options|
+    send_data data, type: :xlsx, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub(".xlsx",'') || 'data'}.xlsx"
+  end
+  ActionController::Renderers.add :ods do |data, options|
+    send_data data, type: :ods, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub(".ods",'') || 'data'}.ods"
+  end
+  ActionController::Renderers.add :csv do |data, options|
+    send_data data, type: :csv, disposition: :attachment, filename: "#{options[:filename] ? options[:filename].sub(".csv",'') || 'data'}.csv"
+  end
+
+
+end

data/lib/spreadsheet_architect/axlsx_column_width_patch.rb

@@ -0,0 +1,13 @@
+if defined? Axlsx
+  Axlsx::Col.class_eval do
+    def width=(v)
+      if v.nil?
+        @custom_width = false
+        @width = nil
+      elsif @width.nil? || @width < v+5
+        @custom_width = @best_fit = v != nil
+        @width = v + 5
+      end
+    end
+  end
+end

data/lib/spreadsheet_architect/set_mime_types.rb

@@ -0,0 +1,10 @@
+if defined? Mime
+  unless defined? Mime::XLSX
+    Mime::Type.register "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", :xlsx
+  end
+  unless defined? Mime::ODS
+    Mime::Type.register "application/vnd.oasis.opendocument.spreadsheet", :ods
+  end
+else
+  puts "Mime module not defined. Skipping registration of xlsx & ods"
+end

data/lib/spreadsheet_architect/version.rb

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

data/test/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: test/spreadsheet_architect.sqlite3.db

data/test/helper.rb

@@ -0,0 +1,52 @@
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.establish_connection(config['sqlite3'])
+ActiveRecord::Schema.define(version: 0) do
+  begin
+  drop_table :posts, :force => true
+  drop_table :other_posts, :force => true
+  rescue
+    #dont really care if the tables are not dropped
+  end
+
+  create_table(:posts, :force => true) do |t|
+    t.string :name
+    t.string :title
+    t.text :content
+    t.integer :votes
+    t.timestamps null: false
+  end
+
+  create_table(:other_posts, :force => true) do |t|
+    t.string :name
+    t.string :title
+    t.text :content
+    t.integer :votes
+    t.timestamps null: false
+  end
+end
+
+class Post < ActiveRecord::Base
+  include SpreadsheetArchitect
+
+  def spreadsheet_columns
+    [:name, :title, :content, :votes, :ranking]
+  end
+
+  def ranking
+    1
+  end
+end
+
+class OtherPost < ActiveRecord::Base
+  include SpreadsheetArchitect
+end
+
+posts = []
+posts << Post.new(name: "first post", title: "This is the first post", content: "I am a very good first post!", votes: 1)
+posts << Post.new(name: "second post", title: "This is the second post", content: "I am the best post!", votes: 7)
+posts.each { |p| p.save! }
+
+posts = []
+posts << OtherPost.new(name: "my other first", title: "first other post", content: "the first other post!", votes: 1)
+posts << OtherPost.new(name: "my other second", title: "second other post", content: "last other post!", votes: 7)
+posts.each { |p| p.save! }

data/test/tc_spreadsheet_architect.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby -w
+require "spreadsheet_architect"
+require 'yaml'
+require 'active_record'
+require 'minitest'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestSpreadsheetArchitect < MiniTest::Test
+  class Post < ActiveRecord::Base
+    include SpreadsheetArchitect
+
+    def self.spreadsheet_columns
+      [:name, :title, :content, :votes, :ranking]
+    end
+
+    def ranking
+      1
+    end
+  end
+
+  class OtherPost < ActiveRecord::Base
+    include SpreadsheetArchitect
+  end
+
+  class PlainPost
+    include SpreadsheetArchitect
+
+    def self.spreadsheet_columns
+      [:name, :title, :content]
+    end
+
+    def name
+      "the name"
+    end
+
+    def title
+      "the title"
+    end
+
+    def content
+      "the content"
+    end
+  end
+
+  test "test_spreadsheet_options" do
+    assert_equal([:name, :title, :content, :votes, :ranking], Post.spreadsheet_columns)
+    assert_equal([:name, :title, :content, :votes, :created_at, :updated_at], OtherPost.column_names)
+    assert_equal([:name, :title, :content], PlainPost.spreadsheet_columns)
+  end
+end
+  
+class TestToCsv < MiniTest::Test
+  test "test_class_method" do
+    p = Post.to_csv(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+  test 'test_chained_method' do
+    p = Post.order("name asc").to_csv(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+end
+
+class TestToOds < MiniTest::Test
+  test 'test_class_method' do
+    p = Post.to_ods(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+  test 'test_chained_method' do
+    p = Post.order("name asc").to_ods(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+end
+
+class TestToXlsx < MiniTest::Test
+  test 'test_class_method' do
+    p = Post.to_xlsx(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+  test 'test_chained_method' do
+    p = Post.order("name asc").to_xlsx(spreadsheet_columns: [:name, :votes, :content, :ranking])
+    assert_equal(true, p.is_a?(String))
+  end
+end