acts_as_xls 1.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gem "rails", "3.0.9"
+gem "spreadsheet"
+gem "axlsx"
+
+group :development, :test do
+  gem "capybara", ">= 0.4.0"
+  gem  "sqlite3"
+  gem  "ruby-debug"
+end
+
+gemspec
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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.rdoc

@@ -0,0 +1,86 @@
+= ActsAsXls
+
+the gem add support for xls, xlsx file generation
+
+==Installation
+
+Add this line to your application's Gemfile:
+
+  gem 'acts_as_xls'
+
+And then execute:
+
+  $ bundle
+
+Or install it yourself as:
+
+  $ gem install acts_as_xls
+
+
+==Usage
+===Controler
+in your controller you can write a render like this:
+
+  #app/controllers/users_controller.rb
+  def index
+    @users = User.all
+    
+    respond_do |format
+      format.xls { render :xls => "index"}
+      format.xlsx { render :xlsx => "index"}
+    end
+  end
+  
+or if you need a quick render, without any template you can write:
+    ...
+    format.xls { render :xls => @users}
+    
+the renderer will call to_xls method to the @users and return the file
+
+Note: if you use render :xlsx => @users you have to implement your own to_xlsx method.
+
+===Views
+you have to create a template in your views folder for xls and xlsx:
+
+xls template expose the book variable, you can use as explained in Spreadsheet guide (http://spreadsheet.rubyforge.org/GUIDE_txt.html)
+
+  #app/views/users/index.xls.maker
+  sheet1 = book.create_worksheet
+  sheet1.name = 'My First Worksheet'
+  x = 0
+  @user.each {|user| sheet1.row(x + 1).concat [user.name, user.age]}
+  
+and for xlsx the template expose the package variable you can use as described in Axlsx site http://axlsx.blogspot.it/
+
+  #app/views/users/index.xlsx.maker
+  package.workbook do |wb|
+    wb.add_worksheet do |sheet|
+      @users.each { |user| sheet.add_row [user.name, user.age]}
+    end
+  end
+  
+then in your view simply link the page using the right format:
+  
+  #app/views/users/index.html.erb
+  <%= link_to "xls", users_path(:format => :xls) %>
+  <%= link_to "xlsx", users_path(:format => :xlsx) %>
+  
+===Options
+You can pass all renderers common options, plus :filename => "my_file_name.xls" | "my_file_name.xlsx" to change the default filename (file.xls or file.xlsx)
+
+==Examples
+You can watch the test/dummy application to find some working examples
+
+==Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+==Thanks
+I want to thanks:
+- Daniel J. Berger, Hannes Wyss, GmbH, creators of the Spreadsheet gem that is the engine of the xls extension
+- randym, creator of the Axlsx gem that powers the xlsx extension ( https://github.com/randym/axlsx )
+

data/Rakefile

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+require 'rubygems'
+begin
+  require 'bundler/setup'
+  require "bundler/gem_tasks"
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rake/testtask'
+
+#require 'rake/rdoctask'
+require 'rdoc/task'
+
+
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsXls'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/acts_as_xls/base.rb

@@ -0,0 +1,41 @@
+require "acts_as_xls/xls"
+
+module ActsAsXls
+  module Base
+    def self.included(base) # :nodoc:
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    #Instance methods for the mixin
+    module InstanceMethods
+    
+      def to_xls(options = {})
+        ActsAsXls::Xls.to_xls(self,options)
+      end
+    end
+    
+    #ToDo
+    #*  to_xlsx
+    #*  to_pdf
+
+    # Class methods for the mixin
+    module ClassMethods
+
+      def new_from_xls(options = {})
+        ActsAsXls::Xls.new_from_xls(self,options)
+      end
+      
+      #ToDo
+      #*  new_from_xlsx
+
+    end
+    
+  end
+
+end
+
+require 'active_record'
+ActiveRecord::Base.send :include, ActsAsXls::Base
+ActiveRecord::Relation.send :include, ActsAsXls::Base
+Array.send :include, ActsAsXls::Base

data/lib/acts_as_xls/engine.rb

@@ -0,0 +1,17 @@
+module ActsAsXls
+  class Engine < Rails::Engine
+
+    #initializer 'usefull_table.helper' do |app|
+    #  ActiveSupport.on_load(:action_controller) do
+    #    include UsefullTableHelper
+    #  end
+    #  ActiveSupport.on_load(:action_view) do
+    #    include UsefullTableHelper
+    #  end
+    #  
+    #end
+  end
+end
+
+require "acts_as_xls/renderer"
+require "acts_as_xls/base"

data/lib/acts_as_xls/exceptions.rb

@@ -0,0 +1,15 @@
+module ActsAsXls
+  class CustomError < StandardError
+    def initialize(*args)
+        @options = args.extract_options!
+        super
+    end
+      
+    def message
+      I18n.t("#{self.class.name.gsub(/::/,'.')}", @options)
+    end
+  end 
+  
+
+end
+

data/lib/acts_as_xls/renderer.rb

@@ -0,0 +1,100 @@
+require "action_controller"
+require "action_view/template"
+
+Mime::Type.register("application/vnd.ms-excel", :xls) unless Mime::Type.lookup_by_extension(:xls)
+Mime::Type.register("application/vnd.openxmlformats", :xlsx) unless Mime::Type.lookup_by_extension(:xlsx)
+#Mime::Type.register("application/pdf", :pdf) unless Mime::Type.lookup_by_extension(:pdf)
+
+#Renderers try to render obj.to_xls
+#then look for *.xls.maker template to render
+ActionController::Renderers.add :xls do |obj, options|
+  options ||= {}
+  filename = options[:filename] || "file.xls"
+  #Rails::logger.info("Renderer(xls) options=#{options.inspect}, obj=#{obj.inspect}")
+  if obj.respond_to?(:to_xls)
+    #No template, must render obj
+    send_data obj.to_xls, :type => Mime::XLS, :filename => filename
+  else
+    send_file render_to_string(options[:template]), :type => Mime::XLS, :disposition => "attachment; filename=#{filename}"
+  end
+  
+end
+
+#Renderers try to render obj.to_xlsx
+#then look for *.xlsx.maker template to render
+ActionController::Renderers.add :xlsx do |obj, options|
+  options ||= {}
+  filename = options[:filename] || "file.xlsx"
+  #Rails::logger.info("Renderer(xlsx) options=#{options.inspect}, obj=#{obj.inspect}")
+  if obj.respond_to?(:to_xlsx)
+    #No template, must render obj
+    send_data obj.to_xlsx, :type => Mime::XLSX, :filename => filename
+  else
+    #Rails::logger.info("Renderer path=#{path}")
+    send_file render_to_string(options[:template]), :type => Mime::XLSX, :disposition => "attachment; filename=#{filename}"
+  end
+end
+
+#~ ActionController::Renderers.add :pdf do |obj, options|
+  #~ options ||= {}
+  #~ filename = options[:filename] || "file.pdf"
+  #~ #Rails::logger.info("Renderer(xlsx) options=#{options.inspect}, obj=#{obj.inspect}")
+  #~ if obj.respond_to?(:to_pdf)
+    #~ #No template, must render obj
+    #~ send_data obj.to_xlsx, :type => Mime::PDF, :filename => filename
+  #~ else
+    #~ #Rails::logger.info("Renderer path=#{path}")
+    #~ send_file render_to_string(options[:template]), :type => Mime::PDF, :disposition => "attachment; filename=#{filename}"
+  #~ end
+#~ end
+
+module ActsAsXls
+  #Render a template like *.[xls|xlsx].maker
+  #the template is evaluated as a ruby expression.
+  #you can use package (xlsx) or book (xls) inside the template to create an excel file 
+  #template return tempfile path tha is rendered by the renderer.
+  module MAKER
+    
+    def self.call(template)
+      %(extend #{Proxy}; #{template.source}; render)
+    end
+    
+    module Proxy
+        def book
+          Spreadsheet.client_encoding = 'UTF-8'
+          @book ||= Spreadsheet::Workbook.new
+        end
+        
+        def render_book
+          @book.write @temp.path if @book
+        end
+                
+        def package
+          @package ||= Axlsx::Package.new
+        end
+        
+        def render_package
+          @package.serialize @temp.path if @package
+        end
+        
+        
+        #~ def pdf
+          #~ @pdf ||= Prawn::Document.new(:page_size => "A4", :margin => [10.28,10,10,10])
+        #~ end
+        
+        #Renders all methods starting form render_
+        #this solution permits to extend che module adding new extesnions and renderers
+        def render
+          @temp = Tempfile.new("tmp")
+          renderers = self.methods.select {|method| method.match(/^render_.*/)}
+          Rails::logger.info("ActsAsXls::MAKER::Proxy renderers=#{renderers.inspect}")
+          renderers.each {|r| eval(r)}
+          @temp.path
+        end
+    end
+    
+  end
+end
+
+
+ActionView::Template.register_template_handler :maker, ActsAsXls::MAKER

data/lib/acts_as_xls/version.rb

@@ -0,0 +1,4 @@
+module ActsAsXls
+  VERSION = "1.0.0"
+end
+

data/lib/acts_as_xls/xls.rb

@@ -0,0 +1,165 @@
+module ActsAsXls
+  module Xls
+    class << self
+      def new_from_xls(base, *args)
+        base.inspect
+      end
+      
+      def to_xls(base_instance, *args, &block)
+        #Rails::logger.info("Array#to_xls dentro")
+        options = args.extract_options!
+        
+        if base_instance.kind_of?(ActiveRecord::Base)
+            #Single ActiveRecord record
+            return to_xls_from_activerecord(base_instance, *(args << options), &block) if base_instance.kind_of?(ActiveRecord::Base)
+        elsif base_instance.kind_of?(Array) || base_instance.kind_of?(ActiveRecord::Relation)
+            #Array of Array or Array of ActiveRecord
+            return to_xls_from_activerecord(nil, *(args << options.merge!({:prepend => base_instance})), &block) if base_instance.first.kind_of?(Array)
+            return to_xls_from_activerecord(base_instance, *(args << options), &block) if base_instance.first.kind_of?(ActiveRecord::Base)
+        else
+          "UnknownType"
+        end
+      end
+      
+      private
+      
+      
+      #==Usage
+      # $ Item.all.to_xlsLa classe restituisce un excel
+      #
+      #Return a binary string of excel with columns title (humanize columns name) and a row for each record
+      #Columns name are used as method to render cell values:
+      # column_name = name   => cell_value = @item.name
+      # column_name = user.name   => cell_value = @item.user.name
+      #
+      #==Options
+      # :only => [...]                                      #List of columns to render
+      # :except => [...]                                  #List of columns not to render (must be in humanized form)
+      # :header => true                                 #Add columns name as title
+      # :header_columns => ["col1", "col2", ..]   #Set columns name
+      # :human => true                                  #Humanize columns name using ActiveRecord Localization
+      # :worksheet => "Foglio1"                      #worksheet name
+      # :file => true                                     #Return a Filetmp instead of a StringIO
+      # :prepend => [["Col 0, Row 0", "Col 1, Row 0"], ["Col 0, Row 1"]]
+      #   Prepend columns and row passed to excel
+      # 
+      # block |column, value, row_index| ....
+      def to_xls_from_activerecord(base_instance, *args, &block)
+        options = args.extract_options!
+        
+        return nil if empty?(base_instance) && options[:prepend].blank?
+
+        #Rails::logger.info("Array#to_xls_from_activerecord(1) dopo primo return")
+
+        columns = []
+        options.reverse_merge!(:header => true)
+        options[:human] ||= true
+        options[:worksheet] ||= "Foglio1"
+        xls_report = StringIO.new
+        book = Spreadsheet::Workbook.new
+        sheet = book.create_worksheet
+        sheet.name = options[:worksheet]
+        
+        sheet_index = 0
+               
+        unless options[:prepend].blank?
+          options[:prepend].each do |array|
+            sheet.row(sheet_index).concat(array)
+            sheet_index += 1
+          end
+        end
+        
+        unless empty?(base_instance)
+          
+          base_instance = base_instance.to_a
+          
+          
+          #Must check culumns name agains methids and removing the non working
+          if options[:only]
+            #columns = Array(options[:only]).map(&:to_sym)
+            columns = Array(options[:only]).map { |column| validate(column,base_instance)}
+            columns.compact!
+          else
+            columns = base_instance.first.class.column_names.map(&:to_sym) - Array(options[:except]).map(&:to_sym)
+          end
+          
+          #Humanize columns name
+          options[:header_columns] ||= columns.map do |column|
+            #Se :human => false non umanizzo i nomi
+            #Iconve risolve i problemi di codifica su caratteri strani tipo � che diventa \340....
+            options[:human] == false ? column.to_s : Iconv.conv("UTF-8", "LATIN1", base_instance.first.class.human_attribute_name(column.to_s.gsub(/\./,"_")))
+          end
+        
+          return nil if columns.empty? && options[:prepend].blank?
+        
+          #Add headers to excel
+          if options[:header]
+            sheet.row(sheet_index).concat(options[:header_columns])
+            sheet_index += 1
+          end
+      
+          base_instance.each_with_index do |obj, index|
+            if block
+              sheet.row(sheet_index).replace(columns.map { |column| block.call(column, get_column_value(obj, column), index) })
+            else
+              sheet.row(sheet_index).replace(columns.map { |column| get_column_value(obj, column) })
+            end
+            
+            sheet_index += 1
+          end
+        end
+        
+        #Rails::logger.info("Spreadsheet::Workbook sheet.rows=#{sheet.rows.inspect}")
+        #Rails::logger.info("Spreadsheet::Workbook book=#{book.inspect}")
+        if options[:file] == true
+          Rails::logger.info("Spreadsheet::Workbook file")
+          tmp = Tempfile.new('tmp_xls')
+          book.write(tmp.path)
+          tmp
+        else
+          Rails::logger.info("Spreadsheet::Workbook stringIO")
+          book.write(xls_report)
+          xls_report.string
+        end
+      end
+    
+      #Rails::logger.info("Array#to_xls_from_activerecord obj.option=#{options.inspect}, self.inspect=#{self.inspect}")
+      #Restituisce il valore della colonna comprese le tabelle collegate
+      #Nel caso il valore della tabella collegata sia nullo restiuisce ""
+      def get_column_value(obj, column) #:doc:
+        if column.to_s.split(".").length > 1
+          securize(obj, column) ? obj.instance_eval(column.to_s) : ""
+        else
+          obj.send(column)
+        end
+      end
+  
+      def securize(obj, column)
+        collection = column.to_s.split(".")
+        if collection.length > 1
+          collection.pop
+          collection = collection.join(".")
+          !obj.instance_eval(collection).blank?
+        else
+          true
+        end   
+      end
+      
+      #Return true if base instance is empty or null
+      def empty?(base_instance)
+        return true if base_instance.nil? 
+        return true if base_instance.blank?
+        false
+      end
+      
+      def validate(column,base_instance)
+        base_instance.first.instance_eval("self." + column.to_s)
+        column.to_sym
+      rescue NoMethodError, RuntimeError
+        nil
+      end
+      
+      
+    end
+  end
+end

data/lib/acts_as_xls.rb

@@ -0,0 +1,9 @@
+module ActsAsXls
+  def self.setup
+  end
+end
+
+require "spreadsheet"
+require "axlsx"
+require "acts_as_xls/engine"
+require "acts_as_xls/exceptions"

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: acts_as_xls
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrea Bignozzi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-29 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Extend Rails capabilities of importing and exporting excel files thanks to Spreadsheet gem
+email: 
+- skylord73@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/acts_as_xls.rb
+- lib/acts_as_xls/engine.rb
+- lib/acts_as_xls/xls.rb
+- lib/acts_as_xls/exceptions.rb
+- lib/acts_as_xls/base.rb
+- lib/acts_as_xls/version.rb
+- lib/acts_as_xls/renderer.rb
+- MIT-LICENSE
+- Rakefile
+- Gemfile
+- README.rdoc
+- CHANGELOG.md
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Extend Rails capabilities of importing and exporting excel files
+test_files: []
+