remote_table 1.2.4 → 1.3.0

data/README.rdoc

@@ -15,7 +15,7 @@ As this library matures, those should go away.
 
 ==Example
 
-    ?> t = RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/98guide6.zip', 'filename' => '98guide6.csv'
+    ?> t = RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/98guide6.zip', :filename => '98guide6.csv'
     => #<RemoteTable:0x359da50 [...]>
     ?> t[0]
     => {"cyl"=>"6", "eng dscr"=>"DOHC VTEC", "trans dscr"=>"2MODE CLKUP", "trans"=>"Auto(L4)", "cmb"=>"20", "2pv"=>nil, "carline name"=>"NSX", "displ"=>"3.0", "ucmb"=>"23.5311", "hpv"=>nil, "4pv"=>nil, "Class"=>"TWO SEATERS", "Manufacturer"=>"ACURA", "fl"=>"P", "2lv"=>nil, "G"=>nil, "hlv"=>nil, "drv"=>"R", "cty"=>"18", "ucty"=>"19.8733", "S"=>nil, "4lv"=>nil, "fcost"=>"1050", "T"=>nil, "hwy"=>"24", "uhwy"=>"30.3612"}

data/lib/remote_table.rb

@@ -28,9 +28,7 @@ class RemoteTable
   autoload :Properties, 'remote_table/properties'
   autoload :LocalFile, 'remote_table/local_file'
   autoload :Transformer, 'remote_table/transformer'
-
-  # singletons
-  autoload :Executor, 'remote_table/executor'
+  autoload :Utils, 'remote_table/utils'
   
   # Legacy
   class Transform
@@ -49,18 +47,17 @@ class RemoteTable
   #     RemoteTable.new(url, options = {})
   #
   # New syntax:
-  #     RemoteTable.new('www.customerreferenceprogram.org/uploads/CRP_RFP_template.xlsx', 'foo' => 'bar')
+  #     RemoteTable.new('www.customerreferenceprogram.org/uploads/CRP_RFP_template.xlsx', :foo => 'bar')
   # Old syntax:
   #     RemoteTable.new(:url => 'www.customerreferenceprogram.org/uploads/CRP_RFP_template.xlsx', :foo => 'bar')
   #
   # See the <tt>Properties</tt> object for the sorts of options you can pass.
   def initialize(*args)
-    @options = args.last.is_a?(::Hash) ? args.last.dup : {}
-    @options.stringify_keys!
+    @options = args.last.is_a?(::Hash) ? args.last.symbolize_keys : {}
     @url = if args.first.is_a? ::String
       args.first.dup
     else
-      @options['url'].dup
+      @options[:url].dup
     end
     @url.freeze
     @options.freeze
@@ -112,15 +109,9 @@ class RemoteTable
   # clear the row cache to save memory
   def free
     cache.clear
-    ::GC.start
     nil
   end
   
-  # Used internally to execute stuff in shells.
-  def self.executor
-    Executor.instance
-  end
-  
   # Used internally to access to a downloaded copy of the file
   def local_file
     @local_file ||= LocalFile.new self

data/lib/remote_table/format/delimited.rb

@@ -1,10 +1,10 @@
 if RUBY_VERSION >= '1.9'
   require 'csv'
-  ::RemoteTable::CSV = ::CSV
+  ::RemoteTable::MyCSV = ::CSV
 else
   begin
     require 'fastercsv'
-    ::RemoteTable::CSV = ::FasterCSV
+    ::RemoteTable::MyCSV = ::FasterCSV
   rescue ::LoadError
     $stderr.puts "[remote_table] You probably need to manually install the fastercsv gem and/or require it in your Gemfile."
     raise $!
@@ -20,8 +20,8 @@ class RemoteTable
         fix_newlines!
         transliterate_whole_file_to_utf8!
         skip_rows!
-        CSV.new(t.local_file.encoded_io, fastercsv_options).each do |row|
-          if row.is_a?(CSV::Row)
+        MyCSV.new(t.local_file.encoded_io, fastercsv_options).each do |row|
+          if row.is_a?(MyCSV::Row)
             hash = row.inject(::ActiveSupport::OrderedHash.new) do |memo, (k, v)|
               if k.present?
                 memo[k] = v.to_s
@@ -35,30 +35,29 @@ class RemoteTable
           end
         end
       ensure
-        t.local_file.delete
+        t.local_file.cleanup
       end
 
       private
 
-      FASTERCSV_OPTIONS = %w{
-        unconverted_fields
-        col_sep
-        headers
-        row_sep
-        return_headers
-        header_converters
-        quote_char
-        skip_blanks
-        converters
-        force_quotes
-      }
+      FASTERCSV_OPTIONS = [
+        :unconverted_fields,
+        :col_sep,
+        :headers,
+        :row_sep,
+        :return_headers,
+        :header_converters,
+        :quote_char,
+        :skip_blanks,
+        :converters,
+        :force_quotes,
+      ]
 
       def fastercsv_options
         hsh = t.options.slice *FASTERCSV_OPTIONS
-        hsh.merge! 'skip_blanks' => !t.properties.keep_blank_rows
-        hsh.reverse_merge! 'headers' => t.properties.headers
-        hsh.reverse_merge! 'col_sep' => t.properties.delimiter
-        hsh.symbolize_keys
+        hsh.merge! :skip_blanks => !t.properties.keep_blank_rows
+        hsh.reverse_merge! :headers => t.properties.headers
+        hsh.reverse_merge! :col_sep => t.properties.delimiter
       end
     end
   end

data/lib/remote_table/format/fixed_width.rb

@@ -19,7 +19,7 @@ class RemoteTable
           yield row if t.properties.keep_blank_rows or row.any? { |k, v| v.present? }
         end
       ensure
-        t.local_file.delete
+        t.local_file.cleanup
       end
       
       private
@@ -42,6 +42,7 @@ class RemoteTable
             d.rows do |row|
               row.trap(&everything)
               t.properties.schema.each do |name, width, options|
+                name = name.to_s
                 if name == 'spacer'
                   row.spacer width
                 else

data/lib/remote_table/format/mixins/processed_by_nokogiri.rb

@@ -7,8 +7,9 @@ class RemoteTable
         raise "[remote_table] Need :row_css or :row_xpath in order to process XML or HTML" unless t.properties.row_css or t.properties.row_xpath
         remove_useless_characters!
         transliterate_whole_file_to_utf8!
-        first_row = true
-        keys = t.properties.headers if t.properties.headers.is_a?(::Array)
+        
+        headers = t.properties.headers
+
         xml = nokogiri_class.parse(unescaped_xml_without_soft_hyphens, nil, 'UTF-8')
         (row_css? ? xml.css(t.properties.row_css) : xml.xpath(t.properties.row_xpath)).each do |row|
           values = if column_css?
@@ -18,22 +19,21 @@ class RemoteTable
           else
             [row]
           end.map { |cell| assume_utf8 cell.content.gsub(/\s+/, ' ').strip }
-          if first_row and t.properties.use_first_row_as_header?
-            keys = values
-            first_row = false
+          if headers == :first_row
+            headers = values.select(&:present?)
             next
           end
           output = if t.properties.output_class == ::Array
             values
           else
-            zip keys, values
+            zip headers, values
           end
           if t.properties.keep_blank_rows or values.any?
             yield output
           end
         end
       ensure
-        t.local_file.delete
+        t.local_file.cleanup
       end
 
       private

data/lib/remote_table/format/mixins/processed_by_roo.rb

@@ -5,44 +5,54 @@ class RemoteTable
       def each(&blk)
         spreadsheet = roo_class.new t.local_file.path, nil, :ignore
         spreadsheet.default_sheet = t.properties.sheet.is_a?(::Numeric) ? spreadsheet.sheets[t.properties.sheet] : t.properties.sheet
+        
+        first_row = if t.properties.crop
+          t.properties.crop.first + 1
+        else
+          t.properties.skip + 1
+        end
+          
+        last_row = if t.properties.crop
+          t.properties.crop.last
+        else
+          spreadsheet.last_row
+        end
+        
         if t.properties.output_class == ::Array
-          (first_row..spreadsheet.last_row).each do |y|
+          (first_row..last_row).each do |y|
             output = (1..spreadsheet.last_column).map do |x|
               assume_utf8 spreadsheet.cell(y, x).to_s.gsub(/<[^>]+>/, '').strip
             end
             yield output if t.properties.keep_blank_rows or output.any? { |v| v.present? }
           end
         else
-          keys = {}
+          headers = {}
           if t.properties.use_first_row_as_header?
             (1..spreadsheet.last_column).each do |x|
-              keys[x] = spreadsheet.cell(first_row, x)
-              keys[x] = spreadsheet.cell(first_row - 1, x) if keys[x].blank? # look up
-              keys[x] = assume_utf8 keys[x]
+              v = spreadsheet.cell(first_row, x)
+              v = spreadsheet.cell(first_row - 1, x) if v.blank? # look up
+              if v.present?
+                v = assume_utf8 v
+                headers[v] = x # 'foobar' is found at column 6
+              end
             end
+            # "advance the cursor"
+            first_row += 1
           else
-            (1..spreadsheet.last_column).each do |x|
-              keys[x] = assume_utf8 t.properties.headers[x - 1]
+            t.properties.headers.each_with_index do |k, i|
+              headers[k] = i + 1
             end
           end
-          (first_row+1..spreadsheet.last_row).each do |y|
-            output = (1..spreadsheet.last_column).inject(::ActiveSupport::OrderedHash.new) do |memo, x|
-              if keys[x].present?
-                memo[keys[x]] = assume_utf8 spreadsheet.cell(y, x).to_s.gsub(/<[^>]+>/, '').strip
-              end
-              memo
+          (first_row..last_row).each do |y|
+            output = ::ActiveSupport::OrderedHash.new
+            headers.each do |k, x|
+              output[k] = assume_utf8 spreadsheet.cell(y, x).to_s.gsub(/<[^>]+>/, '').strip
             end
             yield output if t.properties.keep_blank_rows or output.any? { |k, v| v.present? }
           end
         end
       ensure
-        t.local_file.delete
-      end
-
-      private
-
-      def first_row
-        1 + t.properties.skip
+        t.local_file.cleanup
       end
     end
   end

data/lib/remote_table/format/mixins/textual.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'escape'
 class RemoteTable
   class Format
     module Textual      
@@ -8,35 +7,36 @@ class RemoteTable
         '\xc2\xad',       # soft hyphen, often inserted by MS Office (html: ­)
       ]
       def remove_useless_characters!
-        ::RemoteTable.executor.bang t.local_file.path, "perl -pe 's/#{USELESS_CHARACTERS.join '//g; s/'}//g'"
+        Utils.in_place t.local_file.path, 'perl', '-pe', "s/#{USELESS_CHARACTERS.join '//g; s/'}//g"
         if t.properties.internal_encoding =~ /windows.?1252/i
           # soft hyphen again, as I have seen it appear in windows 1252
-          ::RemoteTable.executor.bang t.local_file.path, %q{perl -pe 's/\xad//g'}
+          Utils.in_place t.local_file.path, 'perl', '-pe', 's/\xad//g'
         end
       end
       
       def transliterate_whole_file_to_utf8!
-        ::RemoteTable.executor.bang t.local_file.path, "iconv -c -f #{::Escape.shell_single_word t.properties.internal_encoding} -t #{::Escape.shell_single_word t.properties.external_encoding_iconv}"
-        t.properties.update 'encoding' => t.properties.external_encoding
+        Utils.in_place t.local_file.path, 'iconv', '-c', '-f', t.properties.internal_encoding, '-t', t.properties.external_encoding_iconv, :ignore_error => true
+        t.properties.update :encoding => t.properties.external_encoding
       end
       
       def fix_newlines!
-        ::RemoteTable.executor.bang t.local_file.path, %q{perl -pe 's/\r\n|\n|\r/\n/g'}
+        Utils.in_place t.local_file.path, 'perl', '-pe', 's/\r\n|\n|\r/\n/g'
       end
       
       def skip_rows!
         return unless t.properties.skip > 0
-        ::RemoteTable.executor.bang t.local_file.path, "tail -n +#{t.properties.skip + 1}"
+        Utils.in_place t.local_file.path, 'tail', '-n', "+#{t.properties.skip + 1}"
       end
       
       def crop_rows!
         return unless t.properties.crop
-        ::RemoteTable.executor.bang t.local_file.path, "tail -n +#{::Escape.shell_single_word t.properties.crop.first.to_s} | head -n #{t.properties.crop.last - t.properties.crop.first + 1}"
+        Utils.in_place t.local_file.path, 'tail', '-n', "+#{t.properties.crop.first}"
+        Utils.in_place t.local_file.path, 'head', '-n', (t.properties.crop.last - t.properties.crop.first + 1).to_s
       end
       
       def cut_columns!
         return unless t.properties.cut
-        ::RemoteTable.executor.bang t.local_file.path, "cut -c #{::Escape.shell_single_word t.properties.cut.to_s}"
+        Utils.in_place t.local_file.path, 'cut', '-c', t.properties.cut.to_s
       end
     end
   end

data/lib/remote_table/local_file.rb

@@ -1,6 +1,5 @@
 require 'fileutils'
-require 'escape'
-require 'tmpdir'
+
 class RemoteTable
   class LocalFile #:nodoc:all
     
@@ -11,7 +10,7 @@ class RemoteTable
     end
     
     def path
-      save_locally
+      generate unless generated?
       @path
     end
     
@@ -23,95 +22,34 @@ class RemoteTable
       end
     end
     
-    def delete
+    def cleanup
       if @encoded_io.respond_to?(:closed?) and !@encoded_io.closed?
         @encoded_io.close
       end
-      ::FileUtils.rm_rf staging_dir_path
       @encoded_io = nil
+      if @path and ::File.exist?(@path)
+        ::FileUtils.rm_f @path
+      end
       @path = nil
-      @staging_dir_path = nil
+      @generated = nil
     end
     
     private
     
-    def staging_dir_path #:nodoc:
-      return @staging_dir_path if @staging_dir_path.is_a?(::String)
-      srand # in case this was forked by resque
-      @staging_dir_path = ::File.join ::Dir.tmpdir, 'remote_table_gem', rand.to_s
-      ::FileUtils.mkdir_p @staging_dir_path
-      @staging_dir_path
-    end
-    
-    def save_locally
-      return if @path.is_a?(::String)
-      @path = ::File.join(staging_dir_path, ::File.basename(t.properties.uri.path))
-      download
-      decompress
-      unpack
-      pick
-      @path
-    end
-    
-    def download
-      if t.properties.uri.scheme == 'file'
-        ::FileUtils.cp t.properties.uri.path, @path
-      else
-        # sabshere 1/20/11 FIXME: ::RemoteTable.config.curl_bin_path or smth
-        # sabshere 7/20/11 make web requests move more slowly so you don't get accused of DOS
-        sleep t.properties.delay_between_requests if t.properties.delay_between_requests
-        $stderr.puts "[remote_table] Downloading #{t.properties.uri.to_s}"
-        ::RemoteTable.executor.backtick_with_reporting %{
-          curl
-          --silent
-          --show-error
-          --location
-          --header "Expect: "
-          #{"--data #{::Escape.shell_single_word t.properties.form_data}" if t.properties.form_data.present?}
-          --output #{::Escape.shell_single_word @path}
-          #{::Escape.shell_single_word t.properties.uri.to_s}
-          2>&1
-        }
-      end
-    end
-    
-    def decompress
-      return unless t.properties.compression
-      new_path = @path.chomp ".#{t.properties.compression}"
-      raise_on_error = true
-      cmd = case t.properties.compression
-      when 'zip', 'exe'
-        # can't set path yet because there may be multiple files
-        raise_on_error = false
-        "unzip -qq -n #{::Escape.shell_single_word @path} -d #{::File.dirname(@path)}"
-      when 'bz2'
-        @path = new_path
-        "bunzip2 --stdout #{::Escape.shell_single_word @path} > #{::Escape.shell_single_word new_path}"
-      when 'gz'
-        @path = new_path
-        "gunzip --stdout #{::Escape.shell_single_word @path} > #{::Escape.shell_single_word new_path}"
-      end
-      ::RemoteTable.executor.backtick_with_reporting cmd, raise_on_error
+    def generated?
+      @generated == true
     end
-    
-    def unpack
-      return unless t.properties.packing
-      cmd = case t.properties.packing
-      when 'tar'
-        "tar -xf #{::Escape.shell_single_word @path} -C #{::File.dirname(@path)}"
+        
+    def generate
+      tmp_path = Utils.download t.properties.uri, t.properties.form_data
+      if compression = t.properties.compression
+        tmp_path = Utils.decompress tmp_path, compression
       end
-      ::RemoteTable.executor.backtick_with_reporting cmd
-    end
-    
-    # ex. A: 2007-01.csv.gz  (compression not capable of storing multiple files)
-    # ex. B: 2007-01.tar.gz  (packing)
-    # ex. C: 2007-01.zip     (compression capable of storing multiple files)
-    def pick
-      if t.properties.filename.present?
-        @path = ::File.join ::File.dirname(@path), t.properties.filename
-      elsif t.properties.glob.present?
-        @path = ::Dir[::File.dirname(@path)+t.properties.glob].first
+      if packing = t.properties.packing
+        tmp_path = Utils.unpack tmp_path, packing
       end
+      @path = Utils.pick tmp_path, :filename => t.properties.filename, :glob => t.properties.glob
+      @generated = true
     end
   end
 end

data/lib/remote_table/properties.rb

@@ -7,22 +7,18 @@ class RemoteTable
     
     def initialize(t)
       @t = t
-      @current_options = t.options.dup
+      @current_options = t.options.symbolize_keys
     end
     
     def update(options)
       current_options.update options
     end
-    
-    def delay_between_requests
-      current_options['delay_between_requests'] || (::ENV.has_key?('REMOTE_TABLE_DELAY_BETWEEN_REQUESTS') ? ::ENV['REMOTE_TABLE_DELAY_BETWEEN_REQUESTS'].to_i : nil)
-    end
-    
+        
     # The parsed URI of the file to get.
     def uri
       return @uri if @uri.is_a?(::URI)
       @uri = ::URI.parse t.url
-      if @uri.host == 'spreadsheets.google.com'
+      if @uri.host == 'spreadsheets.google.com' or @uri.host == 'docs.google.com'
         @uri.query = 'output=csv&' + @uri.query.sub(/\&?output=.*?(\&|\z)/, '\1')
       end
       @uri
@@ -33,19 +29,19 @@ class RemoteTable
     # * call each
     # Defaults to false.
     def streaming
-      current_options['streaming'] || false
+      current_options[:streaming] || false
     end
 
     # Defaults to true.
     def warn_on_multiple_downloads
-      current_options['warn_on_multiple_downloads'] != false
+      current_options[:warn_on_multiple_downloads] != false
     end
     
     # The headers specified by the user
     #
     # Default: :first_row
     def headers
-      current_options['headers'].nil? ? :first_row : current_options['headers']
+      current_options[:headers].nil? ? :first_row : current_options[:headers]
     end
     
     def use_first_row_as_header?
@@ -60,30 +56,30 @@ class RemoteTable
     #
     # Default: 0
     def sheet
-      current_options['sheet'] || 0
+      current_options[:sheet] || 0
     end
     
     # Whether to keep blank rows
     #
     # Default: false
     def keep_blank_rows
-      current_options['keep_blank_rows'] || false
+      current_options[:keep_blank_rows] || false
     end
     
     # Form data to send in with the download request
     def form_data
-      current_options['form_data']
+      current_options[:form_data]
     end
     
     # How many rows to skip
     #
     # Default: 0
     def skip
-      current_options['skip'].to_i
+      current_options[:skip] || 0
     end
     
     def internal_encoding
-      (current_options['encoding'] || 'UTF-8').upcase
+      (current_options[:encoding] || 'UTF-8').upcase
     end
     
     def external_encoding
@@ -98,49 +94,47 @@ class RemoteTable
     #
     # Default: ","
     def delimiter
-      current_options['delimiter'] || ','
+      current_options[:delimiter] || ','
     end
     
     # The XPath used to find rows
     def row_xpath
-      current_options['row_xpath']
+      current_options[:row_xpath]
     end
     
     # The XPath used to find columns
     def column_xpath
-      current_options['column_xpath']
+      current_options[:column_xpath]
     end
 
     # The CSS selector used to find rows
     def row_css
-      current_options['row_css']
+      current_options[:row_css]
     end
     
     # The CSS selector used to find columns
     def column_css
-      current_options['column_css']
+      current_options[:column_css]
     end
     
     # The compression type.
     #
     # Default: guessed from URI.
     #
-    # Can be specified as: "gz", "zip", "bz2", "exe" (treated as "zip")
+    # Can be specified as: :gz, :zip, :bz2, :exe (treated as :zip)
     def compression
-      clue = if current_options['compression']
-        current_options['compression'].to_s
-      else
-        ::File.extname uri.path
+      if current_options.has_key?(:compression)
+        return current_options[:compression]
       end
-      case clue.downcase
+      case ::File.extname(uri.path).downcase
       when /gz/, /gunzip/
-        'gz'
+        :gz
       when /zip/
-        'zip'
+        :zip
       when /bz2/, /bunzip2/
-        'bz2'
+        :bz2
       when /exe/
-        'exe'
+        :exe
       end
     end
     
@@ -148,82 +142,79 @@ class RemoteTable
     #
     # Default: guessed from URI.
     #
-    # Can be specified as: "tar"
+    # Can be specified as: :tar
     def packing
-      clue = if current_options['packing']
-        current_options['packing'].to_s
-      else
-        ::File.extname(uri.path.sub(/\.#{compression}\z/, ''))
+      if current_options.has_key?(:packing)
+        return current_options[:packing]
       end
-      case clue.downcase
-      when /tar/
-        'tar'
+      if uri.path =~ %r{\.tar(?:\.|$)}i
+        :tar
       end
     end
     
     # The glob used to pick a file out of an archive.
     #
     # Example:
-    #     RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/08data.zip', 'glob' => '/*.csv'
+    #     RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/08data.zip', :glob => '/*.csv'
     def glob
-      current_options['glob']
+      current_options[:glob]
     end
     
     # The filename, which can be used to pick a file out of an archive.
     #
     # Example:
-    #     RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/08data.zip', 'filename' => '2008_FE_guide_ALL_rel_dates_-no sales-for DOE-5-1-08.csv'
+    #     RemoteTable.new 'http://www.fueleconomy.gov/FEG/epadata/08data.zip', :filename => '2008_FE_guide_ALL_rel_dates_-no sales-for DOE-5-1-08.csv'
     def filename
-      current_options['filename']
+      current_options[:filename]
     end
     
     # Cut columns up to this character
     def cut
-      current_options['cut']
+      current_options[:cut]
     end
     
     # Crop rows after this line
     def crop
-      current_options['crop']
+      current_options[:crop]
     end
     
     # The fixed-width schema, given as an array
     #
     # Example:
     #     RemoteTable.new('http://cloud.github.com/downloads/seamusabshere/remote_table/test2.fixed_width.txt',
-    #                      'format' => 'fixed_width',
-    #                      'skip' => 1,
-    #                      'schema' => [[ 'header4', 10, { :type => :string }  ],
+    #                      :format => :fixed_width,
+    #                      :skip => 1,
+    #                      :schema => [[ 'header4', 10, { :type => :string }  ],
     #                                  [  'spacer',  1 ],
     #                                  [  'header5', 10, { :type => :string } ],
     #                                  [  'spacer',  12 ],
     #                                  [  'header6', 10, { :type => :string } ]])
     def schema
-      current_options['schema']
+      current_options[:schema]
     end
     
     # The name of the fixed-width schema according to FixedWidth
     def schema_name
-      current_options['schema_name']
+      current_options[:schema_name]
     end
     
     # A proc to call to decide whether to return a row.
     def select
-      current_options['select']
+      current_options[:select]
     end
     
     # A proc to call to decide whether to return a row.
     def reject
-      current_options['reject']
+      current_options[:reject]
     end
     
     # A hash of options to create a new Errata instance (see the Errata gem at http://github.com/seamusabshere/errata) to be used on every row.
     def errata
-      return unless current_options.has_key? 'errata'
-      @errata ||= if current_options['errata'].is_a? ::Hash
-        ::Errata.new current_options['errata']
+      return unless current_options.has_key? :errata
+      @errata ||= if current_options[:errata].is_a? ::Hash
+        ::Errata.new current_options[:errata]
       else
-        current_options['errata']
+        current_options[:errata]
       end
     end
     
@@ -233,15 +224,15 @@ class RemoteTable
     #
     # Default: guessed from file extension (which is usually the same as the URI, but sometimes not if you pick out a specific file from an archive)
     #
-    # Can be specified as: "xlsx", "xls", "csv", "ods", "fixed_width", "html"
+    # Can be specified as: :xlsx, :xls, :delimited (aka :csv and :tsv), :ods, :fixed_width, :html
     def format
-      return Format::Delimited if uri.host == 'spreadsheets.google.com'
-      clue = if current_options['format']
-        current_options['format'].to_s
+      return Format::Delimited if uri.host == 'spreadsheets.google.com' or @uri.host == 'docs.google.com'
+      clue = if current_options.has_key?(:format)
+        current_options[:format]
       else
-        ::File.extname t.local_file.path
+        t.local_file.path
       end
-      case clue.downcase
+      case clue.to_s.downcase
       when /xlsx/, /excelx/
         Format::Excelx
       when /xls/, /excel/