sheety 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d5c92ed5ae6bea6927c5e677aefe279464cf55f
+  data.tar.gz: d8dccac10a9bf260a14ab11f10f00c5f0b786297
+SHA512:
+  metadata.gz: 47e44ab93c4dc032e79e8512622280da7aa9a233ef8387e3a425fc904c305d8508702ec0583ba957ea173ac837eb7f7a8fc0b6e539d6d5b13178a909e8a481e0
+  data.tar.gz: f0cc54c3d2a1c611c960af5b72d8ca0714d3c082bba4934d1a42a80a11bbf637c1d27d3ccf0dec1b2a947de8f9a77262a6a0797ad8fbce34625b0c1b863a29fb

data/lib/sheety.rb

@@ -0,0 +1,49 @@
+module Sheety
+  NEWLINE = "\n"
+
+  def self.length_s(val)
+    if val.respond_to?(:length) then val.length.to_s else "??" end
+  end
+
+end
+
+require_relative 'sheety/api'
+require_relative 'sheety/cell'
+require_relative 'sheety/row'
+require_relative 'sheety/worksheet'
+require_relative 'sheety/spreadsheet'
+
+module Sheety
+  ## Convenience Methods
+  def self.auth
+    return Api.inst.auth
+  end
+
+  def self.sheets(force_refetch=false)
+    return Api.inst.sheets(force_refetch)
+  end
+
+  def self.sheets_where(constraints)
+    return Api.inst.sheets_where(constraints)
+    end
+
+  def self.find_sheet(constraints)
+    return Api.inst.find_sheet(constraints)
+  end
+
+  def self.sheets_except(constraints)
+    return Api.inst.sheets_except(constraints)
+  end
+
+  def self.sheets_except_any(constraints)
+    return Api.inst.sheets_except_any(constraints)
+  end
+
+  def self.list_sheets
+    sheets.each_with_index do |sheet, index|
+      puts "Sheet #{index} - #{sheet}"
+    end
+
+    return nil
+  end
+end

data/lib/sheety/api.rb

@@ -0,0 +1,99 @@
+require "google/api_client"
+require 'xmlsimple'
+
+require_relative 'children'
+require_relative 'spreadsheet'
+
+module Sheety
+
+  private
+
+  class Api
+    include Sheety::Children
+
+    URI_LIST = 'https://spreadsheets.google.com/feeds/spreadsheets/private/full'
+    URI_AUTH = 'https://www.googleapis.com/oauth2/v3/token'
+
+    def link(key) # for compat with ChildBearing
+      return key
+    end
+
+    atom_children :sheets, klass: Sheety::Spreadsheet, link: URI_LIST
+
+    def self.inst
+      if @@instance.nil?
+        @@instance = Sheety::Api.new
+      end
+      return @@instance
+    end
+
+    def auth(force=false)
+      if @access_token.blank? || force
+        data = { :grant_type => 'urn:ietf:params:oauth:grant-type:jwt-bearer', :assertion => @auth.to_jwt.to_s }
+        resp = HTTParty.post(URI_AUTH, { :body => data })
+        if Net::HTTPOK === resp.response
+          @access_token = resp['access_token']
+        end
+      end
+
+      return (@access_token ? self : nil)
+    end
+
+    def get_feed(uri)
+      return parse_response(HTTParty.get(uri, headers: get_headers))
+    end
+
+    def post_feed(uri, data)
+      return parse_response(HTTParty.post(uri, body: data, headers: post_headers))
+    end
+
+    def put_feed(uri, data)
+      return parse_response(HTTParty.put(uri, body: data, headers: put_headers))
+    end
+
+    def delete_feed(uri)
+      return parse_response(HTTParty.delete(uri, headers: delete_headers))
+    end
+
+    private
+
+    def parse_response(resp)
+      begin
+        return XmlSimple.xml_in(resp.body, { 'KeyAttr' => 'name', 'keepnamespace' => true })
+      rescue
+        return resp
+      end
+    end
+
+    def get_headers
+      return auth_headers
+    end
+
+    def post_headers
+      return put_headers
+    end
+
+    def put_headers
+      return auth_headers.merge('Content-Type' => 'application/atom+xml')
+    end
+
+    def delete_headers
+      return auth_headers
+    end
+
+    def auth_headers
+      return { 'Authorization' => "Bearer #{@access_token}" }
+    end
+
+    @@instance = nil
+
+    def initialize
+      @client = Google::APIClient.new(:application_name => 'Sheety', :application_version => "0.1.0")
+      @client.authorization= :google_app_default
+      @auth = @client.authorization
+      @auth.scope = 'https://spreadsheets.google.com/feeds'
+
+      return self
+    end
+  end
+end

data/lib/sheety/cell.rb

@@ -0,0 +1,92 @@
+require_relative 'feed'
+
+class Sheety::Cell < Sheety::Feed
+  COL_LETTERS = [nil, *('A'..'Z')]
+
+  attr_reader :row, :col, :input_value, :numeric_value, :display_value
+
+  def parse(entry)
+    super(entry)
+    cell = entry['gs:cell'][0]
+
+    @row = cell['row'].to_i
+    @col = cell['col'].to_i
+    @input_value = cell['inputValue']
+    @numeric_value = cell['numericValue'].to_f
+    @display_value = cell['content']
+  end
+
+  def value=(new_value)
+    if new_value != @input_value
+      @input_value = new_value
+      @numeric_value = nil
+      @display_value = nil
+    end
+  end
+
+  def col=(c)
+    if @col.nil?
+      @col = c
+    end
+  end
+
+  def row=(r)
+    if @row.nil?
+      @row = r
+    end
+  end
+
+  def rc
+    return "R#{row}C#{col}"
+  end
+
+  def as_xml
+    return [
+        "<entry xmlns=\"http://www.w3.org/2005/Atom\" xmlns:gs=\"http://schemas.google.com/spreadsheets/2006\">",
+        "<id>#{
+        if @id then
+          @id
+        else
+          @parent.link(Sheety::Worksheet::LINK_CELLS) + "/#{rc}"
+        end}</id>",
+        "<link rel=\"#{Sheety::Feed::LINK_EDIT}\" type=\"application/atom+xml\" href=\"#{
+        if link(LINK_EDIT) then
+          link(LINK_EDIT)
+        else
+          @parent.link(Sheety::Worksheet::LINK_CELLS) + "/#{rc}"
+        end}\"/>",
+        "<gs:cell row=\"#{row}\" col=\"#{col}\" inputValue=\"#{input_value}\"/>",
+        "</entry>",
+    ].join(Sheety::NEWLINE)
+  end
+
+  def as_batch_xml
+    return [
+        "<entry>",
+        "<batch:id>#{title}</batch:id>",
+        "<batch:operation type=\"update\" />",
+        "<id>#{id}</id>",
+        "<link rel=\"#{LINK_EDIT}\" type=\"application/atom+xml\"",
+        "href=\"#{link(LINK_EDIT)}\"/>",
+        "<gs:cell row=\"#{@row}\" col=\"#{@col}\" inputValue=\"#{@input_value}\"/>",
+        "</entry>",
+    ].join(Sheety::NEWLINE)
+  end
+
+  def save
+    uri = link(LINK_EDIT)
+    if uri
+      return Sheety::Api.inst.put_feed(uri, as_xml)
+    else
+      return Sheety::Api.inst.post_feed(@parent.link(Sheety::Worksheet::LINK_CELLS), as_xml)
+    end
+  end
+
+  def to_s
+    "<#{self.class}::#{object_id} #{rc} input='#{input_value}' numeric='#{numeric_value}' display='#{display_value}'>"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/lib/sheety/children.rb

@@ -0,0 +1,115 @@
+module Sheety::Children
+  def self.included base
+    base.extend ClassMethods
+  end
+
+  def _passes_constraint(i_val, c_val)
+    case c_val # Good Read: http://ruby.about.com/od/beginningruby/qt/On-Case-And-Class.htm
+      when Range
+        c_val.include? i_val
+      when Array
+        c_val.include? i_val
+      when Regexp
+        c_val =~ i_val
+      when String
+        c_val == i_val.to_s
+      else
+        c_val == i_val
+    end
+  end
+
+  def _get_i_val(item, c_key, accessor=nil)
+    if accessor && item.respond_to?(accessor)
+      return item.send(accessor, c_key)
+    else
+      return item.try(c_key)
+    end
+  end
+
+  module ClassMethods
+    def atom_children(symbol, options)
+
+      if options.blank?
+        raise ArgumentError.new("blank options #{options} are not valid options for bear_children")
+      end
+
+      if options[:klass].blank? || options[:klass].class != Class
+        raise ArgumentError.new("#{options} must have a :klass that is a Class, not a #{options[:klass].class}")
+      end
+
+      if options[:link].blank?
+        raise ArgumentError.new("#{options} must have a non-blank :link")
+      end
+
+      unless method_defined?(:link)
+        raise TypeError.new("#{self} must respond to :link to bear_children")
+      end
+
+      if options[:merge_links] && method_defined?(:add_links) == false
+        raise TypeError.new("#{self} must respond to :add_links to bear_children with mrege_links=true")
+      end
+
+      plural = symbol.to_s
+      singular = plural.singularize
+
+      inst_var_sym = :"@#{symbol}"
+
+      get_method = :"#{plural}"
+      new_method = :"new_#{singular}"
+      enum_method = :"_enumerate_#{plural}_by_method"
+      where_method = :"#{plural}_where"
+      except_method = :"#{plural}_except"
+      except_any_method = :"#{plural}_except_any"
+      find_first_method = :"find_#{singular}"
+
+      define_method(new_method) do |entry=nil|
+        options[:klass].new(self, entry)
+      end
+
+      define_method(get_method) do |force_refetch=false|
+        if instance_variable_get(inst_var_sym).nil? || force_refetch
+          list = Sheety::Api.inst.get_feed(link(options[:link])) # sort of a cyclic dependency, suboptimal
+
+          # TODO: Create a ListFeed Object so the links we get here don't need to be worried about collisions on link ids
+          add_links(list['link']) if !list['link'].blank? && options[:merge_links]
+
+          list = (list['entry'] || []).map do |entry|
+            method(new_method).call(entry)
+          end
+
+          instance_variable_set(inst_var_sym, list)
+        end
+
+        return instance_variable_get(inst_var_sym)
+      end
+
+      define_method(enum_method) do |constraints, method|
+        return method(get_method).call().send(method) do |item|
+          constraints.all? do |constraint|
+            _passes_constraint(_get_i_val(item, constraint[0], options[:accessor]), constraint[1])
+          end
+        end
+      end
+
+      define_method(where_method) do |constraints|
+        return method(enum_method).call(constraints, :find_all)
+      end
+
+      define_method(find_first_method) do |constraints|
+        return method(enum_method).call(constraints, :detect)
+      end
+
+      define_method(except_method) do |constraints|
+        return method(enum_method).call(constraints, :reject)
+      end
+
+      define_method(except_any_method) do |constraints|
+        return method(get_method).call().reject do |item|
+          constraints.any? do |constraint|
+            _passes_constraint(_get_i_val(item, constraint[0], options[:accessor]), constraint[1])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sheety/feed.rb

@@ -0,0 +1,86 @@
+require_relative 'children'
+
+class Sheety::Feed
+  include Sheety::Children
+
+  LINK_SELF = 'self'
+  LINK_EDIT = 'edit'
+  LINK_ALT = 'alternate'
+
+  attr_reader :id, :content, :updated, :parent
+
+  attr_accessor :title
+
+  def initialize(parent, entry=nil)
+    @parent = parent
+    @links = {}
+    unless entry.nil?
+      parse(entry)
+    end
+  end
+
+  def parse(entry)
+    return if entry.blank? || entry.length == 0
+    @title = Sheety::Feed.deref(entry, 'title', 0, 'content')
+    @id = Sheety::Feed.deref(entry, 'id', 0)
+    @content = Sheety::Feed.deref(entry, 'content', 'content')
+    @updated = Sheety::Feed.deref(entry, 'updated', 0)
+    @updated = DateTime.iso8601(@updated) if !@updated.blank?
+    add_links(Sheety::Feed.deref(entry ,'link'))
+  end
+
+  def link(key)
+    @links[key]
+  end
+
+  def as_xml
+    return "<entry></entry>"
+  end
+
+  protected
+
+  def add_links(links)
+    return if links.blank?
+    # Conflict prevention is here to preserve original values parsed from the entities.
+    # This mainly comes into play with the List Feed (a.k.a.: Rows) because we need the
+    #   ability to add new ones.
+    links.each { |link_obj| @links[link_obj['rel']] = link_obj['href'] }
+  end
+
+  def link_edit
+    link(LINK_EDIT)
+  end
+
+  def link_add
+    parent.link(parent.class::LINK_ADD)
+  end
+
+  def save
+    result = if link_edit
+               Sheety::Api.inst.put_feed(link_edit, as_xml)
+             else
+               Sheety::Api.inst.post_feed(link_add, as_xml)
+             end
+    parse(result)
+    return result
+  end
+
+  def to_s
+    "<#{self.class}::#{object_id}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  private
+
+  def self.deref(data, *keys)
+    found = data
+    keys.each do |k|
+      next if found.blank?
+      found = found[k]
+    end
+    return found
+  end
+end

data/lib/sheety/row.rb

@@ -0,0 +1,87 @@
+require_relative 'feed'
+
+class Sheety::Row < Sheety::Feed
+  def initialize(parent, entry=nil)
+    @attrs = {}
+    super(parent, entry)
+  end
+
+  def parse(entry)
+    super(entry)
+    entry.keys.each do |k|
+      if /\Agsx:/i =~ k
+        @attrs[k] = entry[k][0]
+      end
+    end
+  end
+
+  def value(key)
+    return @attrs['gsx:' + key.to_s]
+  end
+
+  alias_method :[], :value
+
+  def []=(key, val)
+    @attrs['gsx:' + key.to_s]=val
+  end
+
+  def put(hash)
+    hash.each { |kv| self[Sheety::Row.normalize_key(kv[0])] = kv[1] }
+  end
+
+  def as_xml
+    return [
+        '<entry xmlns="http://www.w3.org/2005/Atom" xmlns:gsx="http://schemas.google.com/spreadsheets/2006/extended">',
+        if !@id then
+          ''
+        else
+          "<id>#{@id}</id>"
+        end,
+        if !@id then
+          ''
+        else
+          "<updated>#{DateTime.now}</updated>"
+        end,
+        if !@id then
+          ''
+        else
+          '<category scheme="http://schemas.google.com/spreadsheets/2006" term="http://schemas.google.com/spreadsheets/2006#list"/>'
+        end,
+        if !@id then
+          ''
+        else
+          "<link rel=\"edit\" type=\"application/atom+xml\" href=\"#{@links[LINK_EDIT]}\" />"
+        end,
+        *(@attrs.map { |pair| "<#{pair[0]}>#{pair[1]}</#{pair[0]}>" }),
+        '</entry>',
+    ].join(Sheety::NEWLINE)
+  end
+
+  def save
+    uri = link(LINK_EDIT)
+    if uri
+      return Sheety::Api.inst.put_feed(uri, as_xml)
+    else
+      return Sheety::Api.inst.post_feed(@parent.link(Sheety::Worksheet::LINK_POST), as_xml)
+    end
+  end
+
+  alias_method :update, :save
+
+  # ProTip: Delete Rows in Reverse, otherwise the shift of deletion will cause unexpected behaviors
+  def delete
+    return Sheety::Api.inst.delete_feed(link(LINK_EDIT))
+  end
+
+  def to_s
+    "<#{self.class}::#{object_id} #{(@attrs.map { |kv| "#{kv[0].gsub('gsx:', '')}:#{kv[1]}" }).join(', ')}>"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def self.normalize_key(key)
+    key.to_s.gsub(/[^a-zA-Z0-9]/, '')
+  end
+end

data/lib/sheety/spreadsheet.rb

@@ -0,0 +1,87 @@
+require_relative 'feed'
+require_relative 'cell'
+require_relative 'row'
+require_relative 'worksheet'
+
+class Sheety::Spreadsheet < Sheety::Feed
+  LINK_WORKSHEETS = 'http://schemas.google.com/spreadsheets/2006#worksheetsfeed'
+  LINK_ADD = LINK_WORKSHEETS
+
+  atom_children :worksheets, klass: Sheety::Worksheet, link: LINK_WORKSHEETS
+
+  attr_reader :author_name, :author_email
+
+  def parse(entry)
+    super(entry)
+    @author_name = entry['author'][0]['name'][0]
+    @author_email = entry['author'][0]['email'][0]
+  end
+
+  def export_to_worksheet(data, options={})
+    if data.respond_to?(:as_json)
+      data = data.as_json
+    end
+
+    unless !data.blank? && Array === data
+      raise ArgumentError.new("data must be a non-blank array (or convertible by :as_json), got #{data}")
+    end
+
+    options = {title: 'worksheet', timestamp: true}.merge(options)
+
+    headers = data[0].keys
+
+    worksheet = new_worksheet
+    worksheet.col_count = headers.length
+    worksheet.row_count = 1 # we only need to have access to the header row for cells, other rows are inserted
+    worksheet.title = if options[:timestamp] then
+                        "#{options[:title]}_#{Time.now.to_i.to_s}"
+                      else
+                        "#{options[:title]}"
+                      end
+    worksheet.save # save that to create the ws
+
+    worksheet.cells # we need to fetch the link to save new cells to
+
+    headers.each_with_index do |key, index|
+      cell = worksheet.new_cell
+      cell.row = 1
+      cell.col = index + 1
+      cell.value = key.to_s
+      cell.save
+    end
+
+    worksheet.rows # Fetches the link we can save rows to
+
+    # We have to normalize the keys we display to a version without underscores or spaces or other bollocks
+    header_keys = Hash[headers.map { |k| [k, Row.normalize_key(k)] }]
+
+    # TODO: Finish this if I end up caring....
+    # dupes = (header_keys.values - header_keys.values.uniq)
+    #
+    # if dupes.length
+    #
+    # end
+
+    data.each do |datum|
+      row = worksheet.new_row
+      datum.each do |kv|
+        key, val = kv
+        header_key = header_keys[key]
+        row[header_key] = REXML::Text.normalize(val.to_s) unless val.blank?
+      end
+      row.save
+    end
+  end
+
+  ## Serialization Methods
+
+  # TODO: as_xml
+
+  def to_s
+    "<Spreadsheet::#{object_id} '#{title}' by #{author_name} w/ #{Sheety.length_s(@worksheets)} Worksheets>"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/lib/sheety/worksheet.rb

@@ -0,0 +1,94 @@
+require_relative 'feed'
+require_relative 'cell'
+require_relative 'row'
+
+class Sheety::Worksheet < Sheety::Feed
+  LINK_ROWS = 'http://schemas.google.com/spreadsheets/2006#listfeed'
+  LINK_CELLS = 'http://schemas.google.com/spreadsheets/2006#cellsfeed'
+  LINK_VIZ = 'http://schemas.google.com/visualization/2008#visualizationApi'
+  LINK_CSV = 'http://schemas.google.com/spreadsheets/2006#exportcsv'
+  NATIVE_LINKS = [LINK_ROWS, LINK_CELLS, LINK_VIZ, LINK_CSV, LINK_SELF, LINK_EDIT]
+  # TODO: Put these in a ListFeed Object, because that's where they come from
+  LINK_POST = 'http://schemas.google.com/g/2005#post'
+  LINK_FEED = 'http://schemas.google.com/g/2005#feed'
+
+  attr_accessor :col_count, :row_count
+
+  atom_children :rows, klass: Sheety::Row, link: LINK_ROWS, merge_links: true, accessor: :value
+  atom_children :cells, klass: Sheety::Cell, link: LINK_CELLS
+
+  def parse(entry)
+    super(entry)
+
+    @col_count = Sheety::Feed.deref(entry, 'gs:colCount', 0).to_i
+    @row_count = Sheety::Feed.deref(entry, 'gs:rowCount', 0).to_i
+  end
+
+  def update_rows(data, key_key='key', value_key='value')
+    logs = {}
+    row_key_key = Sheety::Row.normalize_key(key_key)
+    row_value_key = Sheety::Row.normalize_key(value_key)
+
+    data.each do |kv|
+      case kv
+        when Array
+          key = kv[0].to_s
+          val = kv[1]
+        when Hash
+          key = kv[key_key].to_s
+          val = kv
+        else
+          raise ArgumentError("Unknown argument type: #{kv.class}")
+      end
+
+      row = find_row(row_key_key => key)
+
+      if row.nil?
+        row = new_row
+        row[row_key_key] = key
+      end
+
+      if Hash === val
+        row.put val
+      else
+        row[row_value_key] = val
+      end
+
+      resp = row.save
+
+      logs[key] = resp unless resp['id']
+    end
+    return logs
+  end
+
+  ## Serialization Methods
+
+  def as_xml
+    return [
+        '<entry xmlns="http://www.w3.org/2005/Atom" xmlns:gs="http://schemas.google.com/spreadsheets/2006">',
+        if @id then
+          "<id>#{@id}</id>"
+        else
+          ''
+        end,
+        "<category scheme=\"http://schemas.google.com/spreadsheets/2006\" term=\"http://schemas.google.com/spreadsheets/2006#worksheet\"/>",
+        "<title type=\"text\">#{title}</title>",
+        if link(LINK_EDIT) then
+          "<link rel=\"#{LINK_EDIT}\" type=\"application/atom+xml\" href=\"#{link(LINK_EDIT)}\"/>"
+        else
+          ''
+        end,
+        "<gs:rowCount>#{row_count}</gs:rowCount>",
+        "<gs:colCount>#{col_count}</gs:colCount>",
+        "</entry>",
+    ].join(Sheety::NEWLINE)
+  end
+
+  def to_s
+    "<Worksheet::#{object_id} '#{title}' (#{col_count} x #{row_count}) w/ #{Sheety.length_s(@rows)} Rows & #{Sheety.length_s(@cells)} Cells>"
+  end
+
+  def inspect
+    to_s
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: sheety
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Blake Israel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.5.pre.bisrael
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.5.pre.bisrael
+- !ruby/object:Gem::Dependency
+  name: google-api-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+description: An interface for manipulating Google Sheets in Ruby on Rails
+email: blake@honkforhelp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sheety.rb
+- lib/sheety/api.rb
+- lib/sheety/cell.rb
+- lib/sheety/children.rb
+- lib/sheety/feed.rb
+- lib/sheety/row.rb
+- lib/sheety/spreadsheet.rb
+- lib/sheety/worksheet.rb
+homepage: https://github.com/honkforhelp/sheety
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A Google Spreadsheets Gem
+test_files: []