importable_attachments 0.0.13

data/lib/importable_attachments/importers/csv.rb

@@ -0,0 +1,208 @@
+module ImportableAttachments
+  module Importers
+    module Csv
+      attr_accessor :validate_headers, :destructive_import, :validate_on_import
+
+      # ImportInto suitable attributes translated from a ImportInto::RECORD_HEADERS
+      # inversion, based on RECORD_HEADERS
+      attr_accessor :converted_headers
+
+      def initialize(attributes = nil, options = {})
+        bootstrap
+        super(attributes, options)
+      end
+
+      # :call-seq:
+      # bootstrap
+      #
+      # :validate_headers - ensures :spreadsheet_columns exist within file
+      # :validate_on_import - validates :import_into records upon import (much slower)
+      # :timestamp_import - sets timestamps of :import_into records upon import (mildly slower)
+      # :destructive_import - makes :import_into reflect most recent file contents (slow)
+
+      def bootstrap
+        @import_rows_to_class = association_symbol_for_rows.to_s.classify.constantize
+        @validate_headers = true
+        @validate_on_import = ::Configuration.for('attachments').validate_on_import
+        @destructive_import = true
+        @timestamp_import = true
+        @converted_headers = set_converted_headers
+      end
+
+      # :call-seq:
+      # attachment= params
+      #
+      # imports an attachment upon assignment if the record is persisted
+      # (if not, after_create hook will import)
+
+      def attachment=(params)
+        super params
+        import_attachment if persisted? && attachment && attachment.valid?
+      end
+
+      # :call-seq:
+      # import_csv
+      #
+      # imports a comma-separated value file
+
+      def import_csv
+        return unless attachment.present?
+        return if validate_headers && !importable_class_headers_ok?
+        transaction do
+          send(association_symbol_for_rows).destroy_all if destructive_import
+          #send import_method, Hash[importable_columns.zip(importable_columns)].symbolize_keys!
+          raise ActiveRecord::Rollback unless import_rows Hash[importable_columns.zip(importable_columns)].symbolize_keys!
+        end
+      end
+
+      # :call-seq:
+      # import_rows *params
+      #
+      # imports a CSV file into @import_rows_to_class
+
+      def import_rows(*params)
+        sanitize_data!
+
+        importer_opts = {}
+        importer_opts.merge! timestamps: true # adds data to converted_headers and spreadsheet
+        importer_opts.merge! validate: validate_on_import
+
+        # .dup else .import modifies converted_headers and spreadsheet
+        if respond_to? :sanitize_data_callback
+          headers, sheet = sanitize_data_callback(converted_headers, spreadsheet)
+        else
+          headers, sheet = converted_headers.dup, spreadsheet.dup
+        end
+        results = @import_rows_to_class.import headers, sheet, importer_opts
+        reload if persisted?
+
+        if results && !results.try(:failed_instances).try(:empty?)
+          opts = {}
+          opts.merge! import_errors_valid: false
+
+          fail_msg = "failed to import #{results.failed_instances.count} record(s)"
+          logger.warn "#{@import_rows_to_class.to_s} #{fail_msg}"
+
+          @row_errors = results.failed_instances.map {|failed_row| "#{failed_row.errors.messages}: #{failed_row.inspect}"}
+          return nil
+        else
+          @row_errors = []
+          return results
+        end
+
+      end
+
+      protected
+
+      # :call-seq:
+      # set_converted_headers
+      #
+      # into model attributes representing has_many_attachments RECORD_HEADERS
+
+      def set_converted_headers
+        header_conversion_chart = @import_rows_to_class.const_get(:RECORD_HEADERS).invert
+        @converted_headers = importable_columns.map { |col| header_conversion_chart[col] }
+      end
+
+      # :call-seq:
+      # importable_columns
+      #
+      # enumeration of spreadsheet columns to import
+
+      def importable_columns
+        @column_names ||= self.class.spreadsheet_columns
+      end
+
+      # :call-seq:
+      # association_symbol_for_rows
+      #
+      # symbol of association representing individual rows of the spreadsheet
+
+      def association_symbol_for_rows
+        @importing_reflection ||= self.class.import_into
+      end
+
+      # :call-seq:
+      # import_method
+      #
+      # TODO: WRITE ME
+
+      def import_method
+        @import_method ||= self.class.import_method
+      end
+
+      # :call-seq:
+      # read_spreadsheet
+      #
+      # the "raw" file as processed by CSV
+
+      def read_spreadsheet
+        csv_klass = (defined? FasterCSV) ? FasterCSV : CSV
+        stream = attachment.io_stream
+        if stream.exists?
+          csv_klass.read stream.path
+        else
+          csv_klass.read stream.queued_for_write[:original].path
+        end
+      end
+
+      # :call-seq:
+      # spreadsheet
+      #
+      # the rows of the file after the first row (headers)
+
+      def spreadsheet
+        read_spreadsheet[1..-1]
+      end
+
+      # :call-seq:
+      # headers
+      #
+      # headers for the spreadsheet
+
+      def headers
+        read_spreadsheet.first
+      end
+
+      # :call-seq:
+      # importable_class_headers_ok?
+      #
+      # requesting to import headers that are not found in the spreadsheet
+
+      def importable_class_headers_ok?
+        extra_headers = importable_columns.map(&:downcase) - headers
+        if extra_headers.empty?
+          @columns_not_found = nil
+          return true
+        else
+          @columns_not_found = extra_headers.join(', ')
+          return false
+        end
+      end
+
+      # :call-seq:
+      # sanitize_data!
+      #
+      # munge data as needed for import e.g. smarter_dates-ish integration
+
+      def sanitize_data!
+        convert_datetimes_intelligently!
+      end
+
+      # :call-seq:
+      # convert_datetimes_intelligently!
+      #
+      # translates English date-ish and-or time-ish language into DateTime instances
+
+      def convert_datetimes_intelligently!
+        dt_attrs = converted_headers.select { |obj| obj.match(/_(?:dt?|at|on)\z/) }
+        dt_idxs = dt_attrs.map { |obj| converted_headers.find_index(obj) }
+
+        spreadsheet.map! { |row|
+          dt_idxs.each { |idx| row[idx] = row[idx].try(:to_datetime) || row[idx] }
+          row }
+      end
+
+    end
+  end
+end

data/lib/importable_attachments/importers/excel.rb

@@ -0,0 +1,37 @@
+module ImportableAttachments
+  module Importers
+    module Excel
+
+      require 'iconv'
+
+      # :call-seq:
+      # import_csv
+      #
+      # imports an Excel (tm) file
+
+      def import_excel
+        column_names = self.class.spreadsheet_columns
+        assoc = self.class.import_into
+        import_method = self.class.import_method
+        return unless attachment.present?
+
+        stream = attachment.io_stream
+        stream_path = if stream.exists?
+          stream.path
+        else
+          stream.queued_for_write[:original].path
+        end
+        spreadsheet = Roo::Excel.new stream_path
+
+        spreadsheet.default_sheet = spreadsheet.sheets.first
+        headers = (1..column_names.length).map { |n| spreadsheet.cell(1, n).try(:downcase) }
+        return unless headers == column_names.map(&:downcase)
+        self.send(assoc).destroy_all
+        2.upto(spreadsheet.last_row) do |line|
+          self.send(import_method, *(1..column_names.length).map { |n| spreadsheet.cell(line, n) })
+        end
+      end
+
+    end
+  end
+end

data/lib/importable_attachments/importers.rb

@@ -0,0 +1,7 @@
+module ImportableAttachments # :nodoc:
+  module Importers # :nodoc:
+  end
+end
+
+require 'importable_attachments/importers/csv'
+require 'importable_attachments/importers/excel'

data/lib/importable_attachments/version.rb

@@ -0,0 +1,3 @@
+module ImportableAttachments
+  VERSION = '0.0.13'
+end

data/lib/importable_attachments.rb

@@ -0,0 +1,9 @@
+require 'configuration'
+require 'importable_attachments/version'
+require 'importable_attachments/engine'
+require 'importable_attachments/base'
+require 'paperclip_processors/save_upload'
+require 'machinist/active_record'
+
+module ImportableAttachments
+end

data/lib/paperclip_processors/save_upload.rb

@@ -0,0 +1,33 @@
+require 'paperclip'
+
+module Paperclip
+
+# force older versions of Paperclip::Upfile to be idempotent
+# https://github.com/thoughtbot/paperclip/issues/315
+  class SaveUpload < Processor
+    # :call-seq:
+    # initialize file, opts, attachment
+    #
+    # file       : File:/tmp/stream_stuff.xls
+    # opts       : has_attached_file(:processors,:attachment_attr)
+    # attachment : Paperclip::Attachment
+
+    def initialize(file, options = {}, attachment = nil)
+      @attachment = attachment
+      @file = file
+    end
+
+    # :call-seq:
+    # make
+    #
+    # called by paperclip after_save
+
+    def make
+      @file.read(1)
+      @file.rewind
+      @file
+    end
+
+  end
+end
+

data/lib/tasks/importable_attachments_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :importable_attachments do
+#   # Task goes here
+# end

data/script/rails

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/importable_attachments/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/spec/attachments/books.csv

@@ -0,0 +1,6 @@
+title,author,last checkout at
+Great Expectations,Charles Dickens,2013-01-01
+A Wrinkle in Time,Madeleine L'Engle,2013-02-28
+Pride and Prejudice,Jane Austen,2012-04-07
+The Grapes of Wrath,John Steinbeck,2012-12-30
+The Three Musketeers,Alexandre Dumas,2013-03-03

data/spec/attachments/books.txt

@@ -0,0 +1,6 @@
+title,author,last checkout at
+Great Expectations,Charles Dickens,2013-01-01
+A Wrinkle in Time,Madeleine L'Engle,2013-02-28
+Pride and Prejudice,Jane Austen,2012-04-07
+The Grapes of Wrath,John Steinbeck,2012-12-30
+The Three Musketeers,Alexandre Dumas,2013-03-03

data/spec/attachments/books2.csv

@@ -0,0 +1,4 @@
+title,author,last checkout at
+Jane Eyre,Charlotte Bronte,2013-01-01
+Hamlet,William Shakespeare,2013-02-01
+Les Miserables,Victor Hugo,2013-03-01

data/spec/attachments/failed_instances.csv

@@ -0,0 +1,3 @@
+title,author,last checkout at
+The Grapes of Wrath,,2013-01-01
+,Robert Frost,2013-02-01

data/spec/attachments/invalid_headers.csv

@@ -0,0 +1,3 @@
+author,last checkout at
+John Steinbeck,2013-01-01
+Charlotte Bronte,2013-02-01

data/spec/attachments/just_headers.csv

@@ -0,0 +1 @@
+just,headers,csv,file

data/spec/attachments/mostly_empty.csv

@@ -0,0 +1,2 @@
+mostly,empty,csv,file
+just,one,for,development

data/spec/controllers/importable_attachments/attachments_controller_spec.rb

@@ -0,0 +1,236 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module ImportableAttachments
+  describe AttachmentsController do
+
+    # :call-seq:
+    # set_request_environment [:options]
+    #
+    # sets request headers e.g. X-File-Nmae, content_type, RAW_POST_DATA
+
+    def set_request_environment(opts = {})
+      lopts = request_environment_opts opts
+      req_env = request.env
+      req_env['X-Requested-With'] = 'XMLHttpRequest' if lopts[:xml]
+      req_env['content_type'] = lopts[:content_type]
+      req_env['X-File-Name'] = File.basename lopts[:spec_file]
+      req_env['RAW_POST_DATA'] = File.new(lopts[:spec_file], 'rb')
+    end
+
+    # :call-seq:
+    # request_environment_opts [:options]
+    #
+    # sets request headers e.g. X-File-Nmae, content_type, RAW_POST_DATA
+
+    def request_environment_opts(opts = {})
+      lopts = {spec_file: @path_to_spec_file, xml: false, content_type: 'application/excel'}
+      lopts.merge opts
+    end
+
+    # :call-seq:
+    # mock_attachment [:opts]
+    #
+    # yields a mock ImportableAttachments::Attachment object
+
+    def mock_attachment(opts = {})
+      lopts = {id: 27,
+        io_stream: nil,
+        io_stream_file_name: 'zero_length.csv',
+        io_stream_content_type: 'Test Content Type',
+        io_stream_file_size: 1,
+        io_stream_updated_at: DateTime.now,
+        revision_number: 1,
+        attachable_type: nil, attachable_id: nil, version: 1}
+      @attachment = mock_model(ImportableAttachments::Attachment, lopts.merge(opts))
+      @attachment.stubs(:io_stream).returns(mock_io_stream(attach_to: @attachment))
+
+      # In the all_controllers_spec case, the file must be copied
+      stream_path = @attachment.io_stream.path.to_s
+      if @spec_file.path != stream_path
+        FileUtils.cp @spec_file, stream_path
+      end
+
+      @attachment
+    end
+
+    # :call-seq:
+    # mock_io_stream [:opts]
+    #
+    # yields a mock Paperclip::Attachment object
+
+    def mock_io_stream(opts = {})
+
+      @io_stream = Paperclip::Attachment.new(:io_stream, @attachment,
+        {path: ':rails_root/public/:rails_env/:style/:attachable_klass/:id_partition/:basename.:stream_version.:extension',
+          preserve_files: true, processors: [:save_upload]})
+      spec_dir = File.dirname(@io_stream.path).sub(/(?:\/\.?)?$/, "")
+      FileUtils.mkdir_p spec_dir unless File.directory? spec_dir
+      @io_stream.stubs(:path).returns(@path_to_spec_file)
+      @io_stream
+    end
+
+    before :each do
+      @path_to_spec_file = Rails.root.join('spec', 'attachments', 'mostly_empty_copy.xls').to_s
+      @spec_file = File.new(@path_to_spec_file, 'rb')
+      @spec_file.stubs(:original_filename).returns(File.basename(@path_to_spec_file))
+      @uploaded_file = fixture_file_upload @path_to_spec_file, 'application/excel'
+
+      mock_attachment
+    end
+
+    # TODO: restore @path_to_spec_file via Git... to be anal
+    after :each do
+    end
+
+    context 'GET index' do
+      it 'assigns all associated attachments as @attachments' do
+        attachments = [@attachment]
+        ImportableAttachments::Attachment.stubs(:order).with(:io_stream_updated_at).returns(attachments)
+        get :index
+        assigns(:attachments).should eq(attachments)
+      end
+    end
+
+    context 'GET show' do
+      it 'should respond with status 200' do
+        ImportableAttachments::Attachment.stubs(:find).with(@attachment.id.to_s).returns(@attachment)
+        path_to = Rails.root.join('spec', 'attachments', @attachment.io_stream_file_name).to_s
+        @io_stream.stubs(:path).returns(path_to)
+        #@attachment.stubs(:io_stream).returns(@io_stream)
+        get :show, id: @attachment.id.to_s
+        response.status.should be 200
+      end
+
+      it 'assigns the requested attachment as @attachment' do
+        ImportableAttachments::Attachment.stubs(:find).with(@attachment.id.to_s).returns(@attachment)
+        get :show, id: @attachment.id.to_s
+        assigns(:attachment).should eq(@attachment)
+      end
+    end
+
+    context 'GET download' do
+      it 'should send the requested attachment as a file' do
+        set_request_environment spec_file: @path_to_spec_file
+        ImportableAttachments::Attachment.stubs(:find).with(@attachment.id.to_s).returns(@attachment)
+        @attachment.stubs(:io_stream_file_name).returns(File.basename(@path_to_spec_file))
+        get :download, id: @attachment.id.to_s
+        response.headers['Content-Disposition'].should == "attachment; filename=\"mostly_empty_copy.xls\""
+      end
+    end
+
+    context 'GET new' do
+      it 'assigns a new attachment as @attachment' do
+        get :new
+        assigns(:attachment).should be_a_new(ImportableAttachments::Attachment)
+      end
+    end
+
+    context 'GET edit' do
+      it 'assigns the requested attachment as @attachment' do
+        ImportableAttachments::Attachment.stubs(:find).with(@attachment.id.to_s).returns(@attachment)
+        get :edit, id: @attachment.id.to_s
+        assigns(:attachment).should eq(@attachment)
+      end
+    end
+
+    context 'POST create' do
+      context 'with valid params' do
+        it 'creates a new ImportableAttachments::Attachment' do
+          set_request_environment
+          expect {
+            post :create, attachment: {io_stream: @uploaded_file}
+          }.to change(ImportableAttachments::Attachment, :count).by(1)
+        end
+
+        it 'assigns a newly created attachment as @attachment' do
+          set_request_environment
+          post :create, attachment: {io_stream: @uploaded_file}
+          assigns(:attachment).should be_a(ImportableAttachments::Attachment)
+          assigns(:attachment).should be_persisted
+        end
+
+        it 'should capture the original filename' do
+          set_request_environment
+          post :create, attachment: {io_stream: @uploaded_file}
+          assigns(:attachment).io_stream_file_name.should == request.env['X-File-Name']
+        end
+
+        it 'should save the file to disk' do
+          set_request_environment
+          post :create, attachment: {io_stream: @uploaded_file}
+          path = assigns(:attachment).io_stream.path
+          path.should_not be_blank
+          File.exist?(path).should == true
+        end
+      end
+
+      context 'with invalid params' do
+        it 'assigns a newly created but unsaved attachment as @attachment' do
+          set_request_environment
+          ImportableAttachments::Attachment.any_instance.expects(:save).returns(false)
+          lambda {
+            post :create, attachment: {io_stream: nil}
+          }.should_not change(@attachment, :io_stream)
+        end
+      end
+    end
+
+    context 'PUT update' do
+      context 'with valid params' do
+        before :each do
+          @path_to_spec_file = Rails.root.join('spec', 'attachments', 'mostly_empty.csv').to_s
+        end
+
+        it 'updates the requested attachment' do
+          set_request_environment
+          attachment = ImportableAttachments::Attachment.create! io_stream: fixture_file_upload(@path_to_spec_file, 'text/csv')
+          ImportableAttachments::Attachment.stubs(:find).with(attachment.id.to_s).returns(attachment)
+          put :update, id: attachment.id.to_s, attachment: {io_stream: @uploaded_file}
+          assigns(:attachment).io_stream_file_name.should == @uploaded_file.original_filename
+        end
+
+        it 'assigns the requested attachment as @attachment' do
+          set_request_environment
+          ImportableAttachments::Attachment.stubs(:find).with(@attachment.id.to_s).returns(@attachment)
+          @attachment.stubs(:update_attributes).with('io_stream' => @uploaded_file).returns(@attachment)
+          put :update, id: @attachment.id.to_s, attachment: {io_stream: @uploaded_file}
+          assigns(:attachment).should eq(@attachment)
+        end
+
+        it 'should create a new version of the file' do
+          set_request_environment
+          attachment = ImportableAttachments::Attachment.create! io_stream: fixture_file_upload(@path_to_spec_file, 'teext/csv')
+          ImportableAttachments::Attachment.stubs(:find).with(attachment.id.to_s).returns(attachment)
+          first_path = attachment.io_stream.path
+          put :update, id: attachment.id.to_s, attachment: {io_stream: @uploaded_file}
+          second_path = assigns(:attachment).io_stream.path
+          first_path.should_not == second_path
+        end
+      end
+
+      context 'with invalid params' do
+        it 'does not update the attachment if the file is not found' do
+          set_request_environment
+          attachment = ImportableAttachments::Attachment.create! io_stream: @uploaded_file
+          ImportableAttachments::Attachment.stubs(:find).with(attachment.id.to_s).returns(attachment)
+          attachment.stubs(:update_attributes).with('these' => 'params').returns(false)
+          lambda {
+            put :update, id: attachment.id.to_s, attachment: {'these' => 'params'}
+          }.should_not change(attachment, :io_stream)
+        end
+      end
+    end
+
+    context 'DELETE destroy' do
+      it 'destroys the requested attachment' do
+        attachment = ImportableAttachments::Attachment.create! io_stream: @uploaded_file
+        ImportableAttachments::Attachment.stubs(:find).with(attachment.id.to_s).returns(attachment)
+        expect {
+          delete :destroy, id: attachment.id.to_s
+        }.to change(ImportableAttachments::Attachment, :count).by(-1)
+      end
+    end
+
+  end
+end
+