file_processor 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--drb
+--debugger

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@file_processor --create

data/.travis.yml

@@ -0,0 +1,3 @@
+nguage: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in file_processor.gemspec
+gemspec
+
+gem 'rake'
+
+group(:development) do
+  gem 'debugger'
+end
+
+group(:test) do
+  gem 'rspec', "~> 2.14.0.rc1"
+  gem 'simplecov'
+  gem 'json', '~> 1.7.7'
+end
+

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    file_processor (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.6.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.1)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.2)
+    diff-lcs (1.2.4)
+    json (1.7.7)
+    multi_json (1.7.4)
+    rake (10.0.4)
+    rspec (2.14.0.rc1)
+      rspec-core (= 2.14.0.rc1)
+      rspec-expectations (= 2.14.0.rc1)
+      rspec-mocks (= 2.14.0.rc1)
+    rspec-core (2.14.0.rc1)
+    rspec-expectations (2.14.0.rc1)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.0.rc1)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  debugger
+  file_processor!
+  json (~> 1.7.7)
+  rake
+  rspec (~> 2.14.0.rc1)
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Vicente Mundim
+
+MIT License
+
+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,56 @@
+# FileProcessor
+
+[![Build Status](https://travis-ci.org/dtmconsultoria/file_processor.png)](https://travis-ci.org/dtmconsultoria/file_processor)
+
+A more powerful CSV file processor
+
+## Installation
+
+FileProcessor uses the new CSV library introduced in Ruby 1.9.3, thus it is only compatible with this Ruby version.
+
+Add this line to your application's Gemfile:
+
+    gem 'file_processor'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install file_processor
+
+## Usage
+
+Use it as you would use Ruby's CSV:
+
+    FileProcessor::CSV.open(filename, options) do |csv|
+      csv.each do |row|
+        # process row here
+      end
+    end # automatically closes the file
+
+FileProcessor::CSV is just a wrapper around Ruby's CSV, so you can manipulate it as you would manipulate Ruby's CSV.
+
+You can also use `FileProcessor::CSV#process_range` to process a range in the file:
+
+    FileProcessor::CSV.open(filename, options) do |csv|
+      csv.process_range(offset: 2000, limit: 1000) do |row, index|
+        # yields 1000 rows starting from line 2000 (i.e., from line 2000 to line 2999)
+      end
+    end # automatically closes the file
+
+Here are the added features:
+
+* Auto-detect encoding of UTF-8 and ISO-8859-1 (Latin1) files.
+* Auto-detect the column separator (`col_sep` option) when not given.
+* Skip lines without data when `skip_blank` is `true`, which is turned on by default. This means that count will not take these lines into account. Also skips them when iterating through lines.
+* Detects if a file is gzipped, and decompress it for you automatically.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/file_processor.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'file_processor/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "file_processor"
+  gem.version       = FileProcessor::VERSION
+  gem.authors       = ["Vicente Mundim"]
+  gem.email         = ["vicente.mundim@gmail.com"]
+  gem.description   = %q{A more powerful CSV file processor}
+  gem.summary       = %q{A more powerful CSV file processor}
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/lib/file_processor/csv.rb

@@ -0,0 +1,186 @@
+module FileProcessor
+  class CSV < SimpleDelegator
+    include Enumerable
+
+    # Opens a file and yields it, ensuring that it is properly closed.
+    def self.open(*args)
+      instance = new(*args)
+
+      if block_given?
+        begin
+          yield instance
+        ensure
+          instance.close if instance
+        end
+      else
+        instance
+      end
+    end
+
+    attr_accessor :detected_encoding
+
+    def initialize(filename, options={})
+      @gzipped      = options.delete(:gzipped)
+
+      load(filename, options.delete(:open_options))
+
+      @options      = default_options.merge(options)
+
+      @options[:encoding] ||= detect_encoding
+      @detected_encoding  ||= Encoding.find(@options[:encoding])
+
+      tempfile.reopen(detected_mode) if tempfile.closed?
+
+      @options[:col_sep]  ||= detect_column_separator
+
+      super(::CSV.new(tempfile, @options))
+    end
+
+    # Counts the number of rows in the file, even if it has already been read
+    #
+    # @return [ Integer ] the number of rows in the file
+    def total_count(&block)
+      rewind
+      count(&block)
+    ensure
+      rewind
+    end
+
+    #
+    # Yields each row of the data source in turn, skipping blanks and rows with no data.
+    #
+    # Support for Enumerable.
+    #
+    # The data source must be open for reading.
+    #
+    def each
+      if block_given?
+        while row = shift
+          yield row unless skip_blanks? && row_with_no_data?(row)
+        end
+      else
+        to_enum
+      end
+    end
+
+    # Process a range of lines in the CSV file.
+    #
+    # @example Process 1000 lines starting from the line 2000
+    #   csv.process_range(offset: 2000, limit: 1000) do |row, index|
+    #     # process range here
+    #   end
+    #
+    # @param [ Hash ] options A hash with offset and/or limit
+    #
+    # @option options [ Integer ] :offset The offset from which the process should start
+    # @option options [ Integer ] :limit  The number of rows to process
+    #
+    # @return [ Enumerable ] CSV's enumerable
+    def process_range(options={})
+      options ||= {}
+
+      offset = options[:offset] || 0
+      limit  = options[:limit]  || -1
+
+      rewind
+      each_with_index do |row, index|
+        next if index < offset
+        break if limit >= 0 && index >= offset + limit
+
+        yield row, index
+      end
+    ensure
+      rewind
+    end
+
+    # Returns true when the file is gzipped, false otherwise
+    def gzipped?
+      @gzipped
+    end
+
+    private
+
+    def detect_compression?
+      @gzipped.nil?
+    end
+
+    def row_with_no_data?(row)
+      row = row.fields if row.respond_to?(:fields)
+      row.all? { |column| column.nil? || column.empty? }
+    end
+
+    def load(filename, open_options)
+      loaded_io = decompress(::Kernel.open(filename, 'rb', open_options || {}))
+      loaded_io.rewind
+
+      @original_default_internal = Encoding.default_internal
+      Encoding.default_internal = nil
+
+      loaded_io.each do |line|
+        tempfile.write(line)
+      end
+    ensure
+      tempfile.close
+      loaded_io.close
+      Encoding.default_internal = @original_default_internal
+    end
+
+    def decompress(loaded_io)
+      if detect_compression? || gzipped?
+        Zlib::GzipReader.open(loaded_io).tap do |decompressed_io|
+          decompressed_io.getc # attempt to read from a compressed io
+          @gzipped = true
+        end
+      else
+        @gzipped = false
+        loaded_io
+      end
+    rescue Zlib::Error
+      # not a compressed io, just returning the loaded io instead
+      @gzipped = false
+      loaded_io
+    end
+
+    # We open the file and try to read each line of it, if there is an
+    # invalid byte sequence, an ArgumentError exception will be thrown.
+    #
+    # We then assume that the file is in ISO-8859-1 encoding, and transcode
+    # it to UTF-8. Though its ugly, this was the only way to detect whether
+    # a file was using one of these encodings.
+    def detect_encoding
+      tempfile.reopen('r:utf-8')
+      tempfile.each(&:split) # raises ArgumentError when it has non-ascii characters that are not in UTF-8
+
+      @detected_encoding = Encoding.find('utf-8')
+    rescue ArgumentError
+      tempfile.reopen('r:iso-8859-1:utf-8')
+      @detected_encoding = Encoding.find('iso-8859-1')
+    ensure
+      tempfile.rewind
+    end
+
+    def detected_utf_8?
+      detected_encoding == Encoding.find('utf-8')
+    end
+
+    def detected_mode
+      detected_utf_8? ? 'r:utf-8' : 'r:iso-8859-1:utf-8'
+    end
+
+    def detect_column_separator
+      @col_sep = tempfile.gets.split(';').size > 1 ? ';' : ','
+    ensure
+      tempfile.rewind
+    end
+
+    def default_options
+      {
+        skip_blanks: true
+      }
+    end
+
+    def tempfile
+      @tempfile ||= FileProcessor::Tempfile.new
+    end
+  end
+end

data/lib/file_processor/temp_file.rb

@@ -0,0 +1,20 @@
+module FileProcessor
+  class Tempfile < ::Tempfile
+    def initialize(basename='file-processor', *args)
+      super(basename, *args)
+    end
+
+    def path
+      @tmpname
+    end
+
+    def reopen(mode)
+      close unless closed?
+      @mode = mode
+
+      @tmpfile = File.open(path, mode, @opts)
+      @data[1] = @tmpfile
+      __setobj__(@tmpfile)
+    end
+  end
+end

data/lib/file_processor/version.rb

@@ -0,0 +1,3 @@
+module FileProcessor
+  VERSION = "0.1.0"
+end

data/lib/file_processor.rb

@@ -0,0 +1,12 @@
+require "file_processor/version"
+require "delegate"
+require "csv"
+require "zlib"
+require "open-uri"
+require "tempfile"
+
+module FileProcessor
+end
+
+require "file_processor/temp_file"
+require "file_processor/csv"

data/spec/file_processor/csv_spec.rb

@@ -0,0 +1,449 @@
+require "spec_helper"
+
+describe FileProcessor::CSV do
+  let(:filename) { fixture('base.csv') }
+  let(:options) { {} }
+
+  subject(:processor) { FileProcessor::CSV.new(filename, options) }
+
+  it "delegates to a CSV instance" do
+    processor.__getobj__.should be_a(::CSV)
+  end
+
+  describe "#col_sep" do
+    context "when it is not given" do
+      context "and the first line of the file has more than one header column separated with a semi-colon" do
+        it "detects it properly" do
+          processor.col_sep.should eq(';')
+        end
+      end
+
+      context "and the first line of the file has more than one header column separated with a comman" do
+        let(:filename) { fixture('base-with-comma-separated-header.csv') }
+
+        it "detects it properly" do
+          processor.col_sep.should eq(',')
+        end
+      end
+
+      context "and an unknown column separator is used" do
+        let(:filename) { fixture('base-with-unknown-column-separator.csv') }
+
+        it "does not detects it, falling back to the default one" do
+          processor.col_sep.should eq(',')
+        end
+      end
+
+      context "and the file has non-ascii characters in its first line" do
+        context "in UTF-8" do
+          let(:filename) { fixture('base-non-ascii-characters-in-header-utf-8.csv') }
+
+          it "detects it properly" do
+            processor.col_sep.should eq(';')
+          end
+        end
+
+        context "in ISO-8859-1" do
+          let(:filename) { fixture('base-non-ascii-characters-in-header-iso-8859-1.csv') }
+
+          it "detects it properly" do
+            processor.col_sep.should eq(';')
+          end
+        end
+      end
+    end
+
+    context "when it is given" do
+      let(:options) { { col_sep: '|' } }
+
+      it "uses the given col_sep" do
+        processor.col_sep.should eq('|')
+      end
+    end
+  end
+
+  describe "#count" do
+    it "returns the number of rows in the CSV" do
+      processor.count.should eq(5)
+    end
+
+    context "when the file has new line characters in a field, but it is properly quoted" do
+      let(:filename) { fixture('base-new-line-in-field.csv') }
+
+      it "returns the correct number of rows in the CSV" do
+        processor.count.should eq(3)
+      end
+    end
+
+    context "when the file has blank lines" do
+      let(:filename) { fixture('base-with-blank-lines.csv') }
+
+      it "skips them by default" do
+        processor.count.should eq(5)
+      end
+    end
+
+    context "when the file has lines with no data" do
+      let(:filename) { fixture('base-with-lines-with-no-data.csv') }
+
+      it "does not count them" do
+        processor.count.should eq(5)
+      end
+
+      context "but skip_blanks is false" do
+        let(:options) { { skip_blanks: false } }
+
+        it "does counts them" do
+          processor.count.should eq(7)
+        end
+      end
+
+      context "and { headers: true } is passed" do
+        let(:options) { { headers: true } }
+
+        it "does not count these lines, as well as the header" do
+          processor.count.should eq(4)
+        end
+      end
+    end
+
+    context "when a block is passed" do
+      let(:filename) { fixture('base-with-lines-with-no-data.csv') }
+
+      it "returns the number of lines for which the block evaluates to true, properly handling lines with no data" do
+        processor.count { |row| !row.first.nil? }.should eq(3)
+      end
+    end
+  end
+
+  describe "#total_count" do
+    it "works as count, but returns all rows, even when called multiple times, since it rewinds the io file" do
+      processor.total_count
+      processor.total_count.should eq(5)
+    end
+  end
+
+  describe "#each" do
+    it "returns an enumerator when called without a block" do
+      processor.each.should be_a(Enumerator)
+    end
+
+    context "when the file has lines with no data" do
+      let(:filename) { fixture('base-with-lines-with-no-data.csv') }
+
+      it "does not yields these lines" do
+        expect { |block|
+          processor.each(&block)
+        }.to yield_control.exactly(5).times
+      end
+
+      context "but skip_blanks is false" do
+        let(:options) { { skip_blanks: false } }
+
+        it "yields these lines" do
+          expect { |block|
+            processor.each(&block)
+          }.to yield_control.exactly(7).times
+        end
+      end
+
+      context "and { headers: true } is passed" do
+        let(:options) { { headers: true } }
+
+        it "does not yields these lines, as well as the header" do
+          expect { |block|
+            processor.each(&block)
+          }.to yield_control.exactly(4).times # header do not count here
+        end
+      end
+    end
+  end
+
+  describe "encoding" do
+    it "can iterate through all of its contents without raising an error" do
+      expect {
+        processor.each {}
+      }.to_not raise_error
+    end
+
+    context "when the encoding is given" do
+      let(:filename) { fixture('base-utf-8.csv') }
+      let(:options) { { encoding: 'utf-8' } }
+
+      its(:detected_encoding) { should eq(Encoding.find(options[:encoding])) }
+
+      it "opens the file properly" do
+        expect {
+          processor
+        }.to_not raise_error
+      end
+
+      context "and the file is ISO-8859-1" do
+        let(:filename) { fixture('base-iso-8859-1.csv') }
+
+        it "uses it to open the file, raising an error" do
+          expect {
+            processor
+          }.to raise_error
+        end
+
+        context "but the given encoding is ISO-8859-1" do
+          let(:options) { { encoding: 'ISO-8859-1' } }
+
+          its(:detected_encoding) { should eq(Encoding.find(options[:encoding])) }
+
+          it "opens the file properly" do
+            expect {
+              processor
+            }.to_not raise_error
+          end
+        end
+      end
+    end
+
+    context "when the file is in US-ASCII" do
+      its(:detected_encoding) { should eq(Encoding.find('utf-8')) }
+
+      it "reads it with utf-8" do
+        processor.encoding.should eq(Encoding.find('utf-8'))
+      end
+    end
+
+    context "when the file can be read in utf-8" do
+      let(:filename) { fixture('base-utf-8.csv') }
+
+      its(:detected_encoding) { should eq(Encoding.find('utf-8')) }
+
+      it "properly detects it" do
+        processor.encoding.should eq(Encoding.find('utf-8'))
+      end
+
+      it "can iterate through all of its contents without raising an error" do
+        expect {
+          processor.each {}
+        }.to_not raise_error
+      end
+    end
+
+    context "when the file cannot be read in utf-8" do
+      context "but it can be read in iso-8859-1" do
+        let(:filename) { fixture('base-iso-8859-1.csv') }
+
+        its(:detected_encoding) { should eq(Encoding.find('iso-8859-1')) }
+
+        it "properly detects it, transcoding it to utf-8" do
+          processor.encoding.should eq(Encoding.find('utf-8'))
+        end
+
+        it "can iterate through all of its contents without raising an error" do
+          expect {
+            processor.each {}
+          }.to_not raise_error
+        end
+
+        context "and no look-ahead is used" do
+          let(:options)  { { row_sep: "\n" } }
+
+          its(:detected_encoding) { should eq(Encoding.find('iso-8859-1')) }
+
+          it "properly detects it, transcoding it to utf-8" do
+            processor.encoding.should eq(Encoding.find('utf-8'))
+          end
+
+          it "can iterate through all of its contents without raising an error" do
+            expect {
+              processor.each {}
+            }.to_not raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe "gzip support" do
+    let(:filename) { fixture('base.csv.gz') }
+
+    it "detects that the file is gzipped and decompress it" do
+      processor.shift.should eq(['A', 'B', 'C']) # first line decompressed
+    end
+
+    it { should be_gzipped }
+
+    context "when the file is in ISO-8859-1 encoding" do
+      let(:filename) { fixture('base-iso-8859-1.csv.gz') }
+
+      it "detects that the file is gzipped and decompress it" do
+        processor.shift.should eq(['A', 'B', 'C']) # first line decompressed
+      end
+
+      it { should be_gzipped }
+    end
+
+    context "when { gzipped: false } options is passed" do
+      let(:options)  { { gzipped: false } }
+
+      context "and the file is not gzipped" do
+        let(:filename) { fixture('base.csv') }
+
+        it { should_not be_gzipped }
+
+        it "does not raise an error" do
+          expect {
+            processor.shift
+          }.to_not raise_error
+        end
+      end
+
+      context "and the file is gzipped" do
+        it "does not attempt to detect it, reading data as it were UTF-8" do
+          processor.shift.should_not eq(['A', 'B', 'C'])
+        end
+      end
+    end
+
+    context "when { gzipped: true } option is passed" do
+      let(:options)  { { gzipped: true } }
+
+      context "and the file is not gzipped" do
+        let(:filename) { fixture('base.csv') }
+
+        it { should_not be_gzipped }
+
+        it "does not raise an error" do
+          expect {
+            processor.shift
+          }.to_not raise_error
+        end
+      end
+
+      context "and the file is gzipped" do
+        it "properly assumes that the file is gzipped and decompress it" do
+          processor.shift.should eq(['A', 'B', 'C']) # first line decompressed
+        end
+      end
+    end
+  end
+
+  describe "#process_range" do
+    it "yields every line of the file by default" do
+      expect { |block|
+        processor.process_range(&block)
+      }.to yield_control.exactly(5).times
+    end
+
+    it "yields the row and its index" do
+      expect { |block|
+        processor.process_range(&block)
+      }.to yield_successive_args(
+        [["A",  "B",  "C"],  0],
+        [["a1", "b1", "c1"], 1],
+        [["a2", "b2", "c2"], 2],
+        [["a3", "b3", "c3"], 3],
+        [["a4", "b4", "c4"], 4]
+      )
+    end
+
+    it "rewinds the file, so it can be called multiple times" do
+      processor.process_range {}
+
+      expect { |block|
+        processor.process_range(&block)
+      }.to yield_successive_args(
+        [["A",  "B",  "C"],  0],
+        [["a1", "b1", "c1"], 1],
+        [["a2", "b2", "c2"], 2],
+        [["a3", "b3", "c3"], 3],
+        [["a4", "b4", "c4"], 4]
+      )
+    end
+
+    context "when an offset is given" do
+      let(:offset) { 2 }
+
+      it "starts from this offset" do
+        expect { |block|
+          processor.process_range(offset: offset, &block)
+        }.to yield_successive_args(
+          [["a2", "b2", "c2"], 2],
+          [["a3", "b3", "c3"], 3],
+          [["a4", "b4", "c4"], 4]
+        )
+      end
+
+      context "and it is equal to the number of lines of the file" do
+        let(:offset) { processor.count }
+
+        it "does not yield" do
+          expect { |block|
+            processor.process_range(offset: offset, &block)
+          }.to_not yield_control
+        end
+      end
+
+      context "and it is greater than to the number of lines of the file" do
+        let(:offset) { processor.count + 1 }
+
+        it "does not yield" do
+          expect { |block|
+            processor.process_range(offset: offset, &block)
+          }.to_not yield_control
+        end
+      end
+    end
+
+    context "when a limit is given" do
+      let(:limit) { 2 }
+
+      it "yields only the number of rows given" do
+        expect { |block|
+          processor.process_range(limit: limit, &block)
+        }.to yield_successive_args(
+          [["A",  "B",  "C"],  0],
+          [["a1", "b1", "c1"], 1]
+        )
+      end
+
+      context "with zero" do
+        let(:limit) { 0 }
+
+        it "does not yield" do
+          expect { |block|
+            processor.process_range(limit: limit, &block)
+          }.to_not yield_control
+        end
+      end
+
+      context "with an offset" do
+        let(:offset) { 2 }
+
+        it "yields only the number of rows given, from the given offset" do
+          expect { |block|
+            processor.process_range(offset: offset, limit: limit, &block)
+          }.to yield_successive_args(
+            [["a2", "b2", "c2"], 2],
+            [["a3", "b3", "c3"], 3]
+          )
+        end
+      end
+    end
+  end
+
+  describe ".open" do
+    subject(:processor) { double(FileProcessor::CSV, close: true) }
+    before { FileProcessor::CSV.stub(:new).with(filename, options).and_return(processor) }
+
+    context "without a block" do
+      it "creates a new instance and returns it" do
+        FileProcessor::CSV.open(filename, options).should eq(processor)
+      end
+    end
+
+    context "with a block" do
+      it "creates a new instance and returns it" do
+        expect { |block|
+          FileProcessor::CSV.open(filename, options, &block)
+        }.to yield_with_args(processor)
+      end
+    end
+  end
+end

data/spec/file_processor/temp_file_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe FileProcessor::Tempfile do
+  subject(:temp_file) { FileProcessor::Tempfile.new }
+  let(:generated_path) { File.join(Dir.tmpdir, 'some-path') }
+
+  it "creates the file" do
+    File.exists?(temp_file.path).should be_true
+  end
+
+  it "opens file ready to be written" do
+    expect {
+      temp_file << "some content"
+    }.to_not raise_error
+  end
+
+  describe "#path" do
+    it "is generated using 'file-processor' basename" do
+      temp_file.path.start_with?(File.join(Dir.tmpdir, 'file-processor')).should be_true
+    end
+  end
+
+  describe "#reopen" do
+    let!(:old_file) { temp_file.__getobj__ }
+
+    it "closes the old file" do
+      old_file.should_receive(:close)
+      temp_file.reopen('r')
+    end
+
+    it "updates the delegated object" do
+      temp_file.reopen('r')
+      temp_file.__getobj__.should_not eq(old_file)
+      temp_file.__getobj__.should be_a(File)
+    end
+
+    it "reopens the path with the given mode" do
+      temp_file.stub(:path).and_return(generated_path)
+      File.should_receive(:open).with(generated_path, 'r:utf-8', 384)
+      temp_file.reopen('r:utf-8')
+    end
+
+    context "when the old file is already closed" do
+      it "does not closes the old file" do
+        old_file.close
+        old_file.should_not_receive(:close)
+        temp_file.reopen('r')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+
+require 'simplecov'
+SimpleCov.start
+
+Bundler.require :default
+
+root = File.expand_path('../..', __FILE__)
+
+Dir[File.join(root, "spec/support/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/support/fixtures/base-iso-8859-1.csv

@@ -0,0 +1,2 @@
+A;B;C
+�;b;c

data/spec/support/fixtures/base-new-line-in-field.csv

@@ -0,0 +1,9 @@
+A;B;C
+"This is
+a field
+
+with new lines";This one has no new line;"But this one has
+also
+
+some new lines"
+Now we have a new row;With data;And more data

data/spec/support/fixtures/base-non-ascii-characters-in-header-iso-8859-1.csv

@@ -0,0 +1,2 @@
+�;B;�
+�;b;�

data/spec/support/fixtures/base-non-ascii-characters-in-header-utf-8.csv

@@ -0,0 +1,2 @@
+Á;B;Ç
+á;b;ç

data/spec/support/fixtures/base-utf-8.csv

@@ -0,0 +1,2 @@
+A;B;C
+á;b;c

data/spec/support/fixtures/base-with-blank-lines.csv

@@ -0,0 +1,7 @@
+A;B;C
+a1;b1;c1
+a2;b2;c2
+
+a3;b3;c3
+
+a4;b4;c4

data/spec/support/fixtures/base-with-comma-separated-header.csv

@@ -0,0 +1,2 @@
+A,B
+a,b

data/spec/support/fixtures/base-with-lines-with-no-data.csv

@@ -0,0 +1,7 @@
+A;B;C
+a1;;
+;;
+;;c2
+;b3;
+;;
+a4;b4;c4

data/spec/support/fixtures/base-with-unknown-column-separator.csv

@@ -0,0 +1,2 @@
+A|B
+a|b

data/spec/support/fixtures/base.csv

@@ -0,0 +1,5 @@
+A;B;C
+a1;b1;c1
+a2;b2;c2
+a3;b3;c3
+a4;b4;c4

data/spec/support/fixtures.rb

@@ -0,0 +1,13 @@
+module FixturesSupport
+  def fixture(filename)
+    File.join(root_path, "/spec/support/fixtures", filename)
+  end
+
+  def root_path
+    File.expand_path('../../..', __FILE__)
+  end
+end
+
+RSpec.configure do |config|
+  config.include FixturesSupport
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: file_processor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Vicente Mundim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-14 00:00:00.000000000 Z
+dependencies: []
+description: A more powerful CSV file processor
+email:
+- vicente.mundim@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- file_processor.gemspec
+- lib/file_processor.rb
+- lib/file_processor/csv.rb
+- lib/file_processor/temp_file.rb
+- lib/file_processor/version.rb
+- spec/file_processor/csv_spec.rb
+- spec/file_processor/temp_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+- spec/support/fixtures/base-iso-8859-1.csv
+- spec/support/fixtures/base-iso-8859-1.csv.gz
+- spec/support/fixtures/base-new-line-in-field.csv
+- spec/support/fixtures/base-non-ascii-characters-in-header-iso-8859-1.csv
+- spec/support/fixtures/base-non-ascii-characters-in-header-utf-8.csv
+- spec/support/fixtures/base-utf-8.csv
+- spec/support/fixtures/base-with-blank-lines.csv
+- spec/support/fixtures/base-with-comma-separated-header.csv
+- spec/support/fixtures/base-with-lines-with-no-data.csv
+- spec/support/fixtures/base-with-unknown-column-separator.csv
+- spec/support/fixtures/base.csv
+- spec/support/fixtures/base.csv.gz
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -785318963478006114
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -785318963478006114
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A more powerful CSV file processor
+test_files:
+- spec/file_processor/csv_spec.rb
+- spec/file_processor/temp_file_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures.rb
+- spec/support/fixtures/base-iso-8859-1.csv
+- spec/support/fixtures/base-iso-8859-1.csv.gz
+- spec/support/fixtures/base-new-line-in-field.csv
+- spec/support/fixtures/base-non-ascii-characters-in-header-iso-8859-1.csv
+- spec/support/fixtures/base-non-ascii-characters-in-header-utf-8.csv
+- spec/support/fixtures/base-utf-8.csv
+- spec/support/fixtures/base-with-blank-lines.csv
+- spec/support/fixtures/base-with-comma-separated-header.csv
+- spec/support/fixtures/base-with-lines-with-no-data.csv
+- spec/support/fixtures/base-with-unknown-column-separator.csv
+- spec/support/fixtures/base.csv
+- spec/support/fixtures/base.csv.gz