spodunk 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec"
+  gem "bundler"
+  gem "jeweler"
+  gem 'vcr'
+  gem 'webmock'
+  gem 'dotenv'
+end
+
+gem 'pry'
+gem 'hashie'
+gem 'google_drive'
+gem 'activesupport', "~> 3.2.15"

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 dannguyen
+
+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,4 @@
+# Spodunk
+
+A futile attempt to use spreadsheets as ad-hoc databases
+

data/Rakefile

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "spodunk"
+  gem.homepage = "http://github.com/dannguyen/spodunk"
+  gem.license = "MIT"
+  gem.summary = %Q{A quickie wrapper to use Google Spreadsheets as a database}
+  gem.description = %Q{Spodunk stands for "spreadsheet" + "podunk"}
+  gem.email = "dansonguyen@gmail.com"
+  gem.authors = ["dannguyen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/go.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'dotenv'
+dotpath = File.expand_path File.join(File.dirname(__FILE__), '..', '.env')
+# puts dotpath
+Dotenv.load dotpath
+
+require 'spodunk'
+include Spodunk
+
+
+
+@creds = {email: ENV['GDRIVE_TEST_EMAIL'], password: ENV['GDRIVE_TEST_PASSWORD']}
+@url = ENV['GDRIVE_TEST_SPREADSHEET_URL']
+@title = ENV['GDRIVE_TEST_WORKSHEET_TITLE']
+
+@gd = Connection::GDrive.new(@creds, url: @url)
+@gd.load_table('models')
+
+@rows = @gd.table('models').rows
+
+

data/lib/spodunk/connection.rb

@@ -0,0 +1,79 @@
+module Spodunk
+  module Connection
+    class Base
+      attr_reader :session, :spreadsheet
+
+      # the interface between Hash objects and Google Spreadsheets
+      def initialize(*args)
+        @tables = {}
+      end
+
+      
+
+      def load_table(title)
+        unless title.nil?
+          @tables[title] = {}
+          @tables[title][:real] = real_t = fetch_real_table_object(title)
+          @tables[title][:podunk] = init_podunk_table(real_t, title: title)
+        end
+      end
+
+
+
+
+      def load_spreadsheet(*args);end
+
+      def real_tables(tid)
+        if t = @tables[tid]
+          return t[:real]
+        end
+      end
+
+      def tables(tid)
+        if t = @tables[tid]
+          return t[:podunk]
+        end
+      end
+
+      def table(tid)
+        tables(tid)
+      end
+
+      def save_row(table_id, row)
+        pt = tables(table_id)
+        row_idx = pt.real_row_index(row)
+
+        row.itemized_changes.each_pair do |col_idx, val|
+          save_cell(table_id, row_idx, col_idx, val)
+        end
+      end
+
+      def save_table(table_id)
+        pt = tables(table_id)
+
+        # expects itemized_changes to be {[2,3] => 4}
+        #  with row_offset and col_offset already applied
+        pt.itemized_changes.each_pair do |(r, c), val|
+          save_cell(table_id, r, c, val)
+        end
+      end
+
+      # arr_xy is something like [2,3] (row 2, col 3)
+      #  expects arr_xy to contain offset-applied row and col index
+      def save_cell(table_id, real_row_idx, real_col_idx, val)
+        # abstract
+      end
+
+
+
+
+
+      protected
+      def init_podunk_table(*args); end
+      def fetch_real_table_object(*args); end
+
+    end
+  end
+end
+
+require 'spodunk/connections/gdrive'

data/lib/spodunk/connections/gdrive.rb

@@ -0,0 +1,63 @@
+require 'google_drive'
+module Spodunk
+  module Connection
+    class GDrive < Base
+
+      # the interface between Hash objects and Google Spreadsheets
+      def initialize(creds, sheet_opts={})
+        # old style auth
+        if creds[:email] && creds[:password]
+          @session = GoogleDrive.login creds[:email], creds[:password]
+        end
+        @spreadsheet = load_spreadsheet(sheet_opts)
+
+        super
+      end
+
+      
+
+
+      # url is something like:
+      # 
+      # https://docs.google.com/spreadsheet/ccc?key=xXcdHmAt3Q3D3lDx&usp=drive_web#gid=0
+      def load_spreadsheet(opts)
+        if opts[:url]
+          @session.spreadsheet_by_key parse_gdoc_url_for_key(opts[:url])
+        elsif opts[:key]
+          @session.spreadsheet_by_key(opts[:key])
+        end
+      end
+
+
+      # via: https://github.com/gimite/google-drive-ruby#how-to-use
+      def save_cell(table_id, real_row_idx, real_col_idx, val)
+        r_table = real_tables(table_id) # i.e. a Google Worksheet
+        r_table[real_row_idx, real_col_idx] = val
+
+        r_table.save
+      end
+
+
+      protected
+      # returns a string for key
+      def parse_gdoc_url_for_key(url)
+        u = URI.parse(url)
+   
+        key = CGI.parse(u.query)['key'][0]
+      end
+
+
+      # sets up the table structure
+      def init_podunk_table(gsheet, opts={})
+        Table.new(gsheet.rows, opts)
+      end
+
+
+      def fetch_real_table_object(title)
+        @spreadsheet.worksheet_by_title(title)
+      end
+
+
+    end
+  end
+end

data/lib/spodunk/row.rb

@@ -0,0 +1,139 @@
+require 'hashie'
+
+module Spodunk
+  class Row
+    attr_reader :mash, :original, :timestamp
+
+    delegate :values, :keys, :to => :mash
+    delegate :values, :to => :original, prefix: true
+    # expects vals and headers to be 1 to 1
+
+
+    def initialize(vals, headers)
+      slugged_headers = headers.map{|h| h.slugify}
+      @mash = Hashie::Mash.new(Hash[slugged_headers.zip(vals)])
+      @original = @mash.dup.freeze
+      @timestamp = Time.now 
+    end
+
+
+    def changes(opts={})
+      offset = opts[:col_offset]
+      diff.inject({}) do |h, (k,v)|
+        x = offset ? mash_index(k) + offset : k
+        h[x] = v.last
+ 
+        h
+      end
+    end
+
+    # by default, spreadsheets are assumed to be numbered with columns
+    # starting from 1
+    def itemized_changes
+      changes(col_offset: 1)
+    end
+
+    # finds difference between @originals and @mash
+    def diff
+      dirty_diff(@original, @mash)
+    end
+
+    def clean?
+      diff.empty?
+    end
+
+    def dirty?
+      !clean?
+    end
+
+
+    def [](key)
+      @mash[mash_key(key)]
+    end
+
+    def []=(key, val)
+      @mash[mash_key(key)] = val
+    end
+
+    def method_missing(foo, *args, &blk)
+      foop = foo.to_s.match(/\w+(?==)?/).to_s
+      if @mash.keys.include?(foop)
+        @mash.send(foo, *args)
+      else
+        super
+      end
+    end
+
+    def respond_to?(foo, inc_private=false)
+      foop = foo.to_s.match(/\w+(?=$|=)/).to_s
+      if @mash.keys.include?(foop)
+        true
+      else
+        super
+      end
+    end
+
+
+    def attributes
+      @mash.stringify_keys
+    end
+
+    def assign_attributes(hsh)
+      new_atts = hsh.inject({}) do |h, (k, v)|
+        if has_attribute?(k)
+          # ignore attributes that aren't part of the model
+          h[mash_key(k)] = v
+        end
+
+        h
+      end
+
+      @mash.merge!( new_atts )
+    end
+
+
+    def has_attribute?(k)
+      attributes.keys.include?(mash_key(k))
+    end
+
+    private
+
+    # Since Rails diff is being deprecated
+    # this is a simple hack that DOES NOT do nested hashes
+    # and expects m1 and m2 to have EXACTLY the same stringified keys
+    #
+    # returns a hash with an array of differences
+    # {
+    #   a: ['before', 'after'],
+    #   b: [nil, 'now']
+    # }
+
+    def dirty_diff(h1, h2)
+      h1.stringify_keys.inject({}) do |h, (k, v1)|
+        v2 = h2[k]
+        h[k] = [v1, v2] if v1 != v2
+        
+        h  
+      end
+    end
+
+    # a method that converts integer vals or Strings to proper 
+    # slugified keys
+    def mash_key(idx)
+      if idx.is_a?(Fixnum)
+        return keys[idx]
+      else
+        return idx.to_s.slugify
+      end
+    end
+
+    def mash_index(key)
+      if key.is_a?(Fixnum)
+        return key
+      else
+        return keys.index(key.to_s)
+      end
+    end
+
+  end
+end

data/lib/spodunk/table.rb

@@ -0,0 +1,104 @@
+require 'active_support/all'
+
+module Spodunk
+  class Table
+
+    attr_reader :headers, :rows, :title, :slug_headers, 
+                :row_offset, :col_offset
+
+    def initialize(arr, opts={})
+      rs = arr.dup
+      @headers = rs.shift
+      @slug_headers = @headers.map{|h| h.slugify}
+      # rows get attributes as slugs
+      @rows = rs.map{ |r| Row.new(r, @slug_headers)}
+
+      @title = opts[:title]
+
+      # most spreadsheets start counting from 1
+      # and the first row is technically at index-2
+      #  since headers is index-1
+      @row_offset = opts[:row_offset] || 2
+
+      # most spreadsheets begin column counting at 1
+      @col_offset = opts[:col_offset] || 1
+    end
+
+    def real_row_index(row)
+      if row.is_a?(Fixnum)
+        idx = row
+      else
+        idx = @rows.index(row)
+      end
+
+      return idx + @row_offset
+    end
+
+
+    def num_rows
+      @rows.count
+    end
+
+    def num_cols
+      @headers.count
+    end
+
+
+    def valid?
+      @slug_headers.uniq.count == num_cols
+    end
+
+    def clean_rows
+      @rows.reject{|r| r.dirty?}
+    end
+
+    def dirty_rows
+      @rows.select{|r| r.dirty?}
+    end
+
+    def clean?
+      dirty_rows.empty?
+    end
+
+    def dirty?
+      !clean?
+    end
+
+    # returns with 0-based index and column names as Strings
+    def changes(opts={})
+      row_offset = opts[:row_offset].to_i
+
+      dirty_rows.inject({}) do |h, row|
+        idx = @rows.index(row) + row_offset
+        h[idx] = row.changes(opts)
+ 
+        h
+      end     
+    end
+
+    # returns format more specific for Google Worksheets
+    # with 1-based index and Hash with column indices rather than
+    #  Strings
+    def offset_changes
+      changes(col_offset: @col_offset, row_offset: @row_offset)
+    end
+
+    # similar to offset_changes, except hash contains keys
+    # of [row, val] Arrays
+    def itemized_changes
+      offset_changes.inject({}) do |h, (row_num, col_hsh) |
+        col_hsh.each_pair do |col_num, val|
+          h[[row_num, col_num]] = val
+        end
+        
+        h
+      end
+    end
+
+  # define unique ID field or concatenation
+
+
+   
+
+  end
+end

data/lib/spodunk.rb

@@ -0,0 +1,16 @@
+require 'active_support/all'
+
+module Spodunk
+  NULL_FIELD_VALUE = "!NULL"
+end
+
+require 'spodunk/connection'
+require 'spodunk/table'
+require 'spodunk/row'
+
+
+class String
+  def slugify
+    self.underscore.parameterize.underscore
+  end
+end

data/spec/lib/convenience_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'conveniences' do
+
+
+  describe 'slugify' do
+    it 'should underscore and strip' do 
+      expect('Hey'.slugify).to eq 'hey'
+      expect('heyYou'.slugify).to eq 'hey_you'
+      expect('Hey you'.slugify).to eq 'hey_you'
+      expect('Hey ! !!! you!  !'.slugify).to eq 'hey_you'
+      expect('hey_you'.slugify).to eq 'hey_you'
+    end
+  end
+
+end

data/spec/lib/row_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+
+describe "Spodunk::Row" do
+
+  let(:headers){ %w(Apples Oranges Blue-kiwi) }
+  let(:values){ [20, 9, 'none'] }
+
+  before{ @row = Row.new(values, headers)}
+
+  describe 'initialization' do
+    it 'should accept values and headers array and make a mash' do
+      expect(@row).to be_a Row
+      expect(@row.mash).to be_a Hashie::Mash
+      expect(@row.original).to be_a Hashie::Mash
+    end
+ 
+    it 'should delegate values and in the @mash' do
+      expect(@row.values).to eq values
+    end
+
+    it 'should delegate keys to @mash, but @mash has them slugified' do
+      expect(@row.keys).to eq headers.map{|h| h.slugify}
+    end
+
+    it 'should have method_missing apply to slugified headers' do
+      expect(@row.blue_kiwi).to eq 'none'
+      expect(@row.respond_to?(:oranges)).to be_true
+    end
+
+    it 'should have method_missing apply to slugified headers with assignment' do
+      @row.blue_kiwi = 'some'
+      expect(@row.blue_kiwi).to eq 'some'
+      expect(@row.respond_to?(:oranges=)).to be_true
+    end
+
+
+    it 'should have #original_values' do
+      expect(@row.original_values).to eq values
+    end
+
+    it 'should allow access by column index by delegating to @values' do
+      expect(@row[1]).to eq 9
+    end
+
+    it 'should be timestamped' do
+      expect(@row.timestamp).to be_within(10).of(Time.now)
+    end
+  end
+
+  context 'changes' do
+    before do
+      @row[0] = 20 # no change
+      @row[1] = 200
+      @row[2] = nil
+    end
+
+    describe 'dirty?' do
+      it 'should be true if anything has changed' do
+        @row[1] = 20
+        expect(@row).to be_dirty
+      end
+    end
+
+    describe 'diff' do
+      it 'should list all changes' do
+        expect(@row.diff).to eq({
+          'oranges' => [9, 200],
+          'blue_kiwi' => ['none', nil] 
+        })      
+      end
+    end
+
+    describe '#changes' do
+      it 'by default, returns a Hash header-names as keys' do
+        expect(@row.changes).to eq({
+          'oranges' => 200,
+          'blue_kiwi' => nil
+        })        
+      end
+
+      it 'should take :offset option' do
+        expect(@row.changes(col_offset: 0)).to eq({
+            1 => 200,
+            2 => nil
+          }
+        )
+      end
+
+      it 'should have #itemized_changes as convenience' do
+        expect(@row.itemized_changes).to eq({
+            2 => 200,
+            3 => nil
+          }
+        )
+
+        expect(@row.itemized_changes).to eq @row.changes(col_offset: 1)
+      end
+    end
+  end
+
+  context '#attributes' do
+    let(:headers){ %w(Apples Oranges Blue-kiwi) }
+    let(:values){ [20, 9, 'none'] }
+
+    before{ @row = Row.new(values, headers)}
+
+    it 'should be the same as @mash, with string keys' do 
+      expect(@row.attributes).to eq @row.mash.stringify_keys
+    end
+
+    describe '#has_attribute?' do
+      it 'checks on string equality' do
+        expect(@row.has_attribute?('Blue-kiwi')).to be_true
+        expect(@row.has_attribute?('blue_kiwi')).to be_true
+        expect(@row.has_attribute?('red_kiwi')).to be_false
+
+        # note, headers are slugified at the Table level
+        # not when we initialize rows manually
+      end
+    end
+
+
+    describe '#assign_attributes' do
+      it 'should modify the row' do
+        @row.assign_attributes('Blue-kiwi' => 5)
+        expect(@row).to be_dirty
+        expect(@row.attributes['blue_kiwi']).to eq 5
+      end
+
+      it 'should work with slugified attributes' do
+        @row.assign_attributes('blue_kiwi' => 'yay')
+
+        expect(@row.attributes['blue_kiwi']).to eq 'yay'
+      end
+
+      it 'should silently ignore non-existent attributes' do
+        @row.assign_attributes('nothing_here' => 99)
+        expect(@row.attributes['nothing_here']).to be_nil
+        expect(@row).not_to be_dirty
+      end
+    end
+  end
+
+
+
+end

data/spec/lib/table_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe Spodunk::Table do
+
+  context 'basic ops' do 
+    let(:rows){[ 
+      ['Hello', 'world', "It's me"],
+      ['a', 1, "99"]
+    ]}
+    before do
+      @table = Table.new(rows)
+    end
+
+    describe 'initialization by rows' do
+      it 'should accept array as first argument ' do
+        expect(@table).to be_a Table
+      end
+
+      it 'should not modify original array' do
+        expect(rows.count).to eq 2
+      end
+    end
+
+    describe 'rows and indicies' do
+      it 'should have basic counts' do
+        expect(@table.num_rows).to eq 1
+        expect(@table.num_cols).to eq 3
+      end
+
+      describe '#real_row_index' do
+        it 'by default has @row_offset of 2' do
+          expect(@table.row_offset).to eq 2
+        end
+    
+        it 'by default has @col_offset of 1' do 
+          expect(@table.col_offset).to eq 1
+        end
+
+        it 'uses @row_offset in real_row_index' do
+          expect(@table.real_row_index(0)).to eq 2
+        end
+
+        it 'can take in a Spodunk::Row as argument' do
+          row = @table.rows.first
+
+          expect(@table.real_row_index(row)).to eq 2
+        end
+      end
+    end
+
+    describe '@headers' do
+      it 'should by default be first row' do
+        expect(@table.headers).to eq rows.first
+      end
+    end
+
+    describe '@rows' do
+      it 'should convert all rows to SpreadtableConnection::Row' do
+        expect(@table.rows.all?{|r| r.is_a?(Row)})
+      end
+
+      it 'should same as source arr, minus headers' do
+        expect(@table.rows[0].values).to eq rows.last
+      end      
+    end
+  end
+
+
+  describe 'validation' do
+    it 'should be valid? if all headers are sluggibly unique' do
+      table = Table.new([
+        ['hey you', 'hey- there'],
+        [1,2]
+      ])
+
+      expect(table).to be_valid
+    end
+
+    it 'should not allow headers with same sluggable name' do
+      table = Table.new([
+        ['hey you', 'hey-you   '],
+        [1,2]
+      ])
+
+      expect(table).not_to be_valid
+    end    
+  end
+
+  describe 'configuration' do
+
+  end
+
+  describe 'factory methods' do
+    describe 'initialization with a key' do
+
+
+    end
+  end
+
+
+  context 'dirtiness' do
+    let(:rows){[ 
+      ['Hello', 'world', "It's me"],
+      ['a', 1, "99"]
+    ]}
+
+    before do
+      @table = Table.new(rows)
+      @row = @table.rows.first
+      @row['world'] = 'changed'
+    end
+
+    it 'should be #dirty?' do
+      expect(@table).to be_dirty
+    end
+
+    describe '#changes' do
+      it 'should list changes' do
+        expect(@table.changes).to eq({
+          0 => {'world' => 'changed'}
+        })
+      end
+
+      it '#offset_changes should list changes with 1-based index and col numbers' do
+        expect(@table.offset_changes).to eq({
+          2 => { 2 => 'changed'}
+        })
+      end
+
+      it '#itemized_changes should be Hash with [row,col] as keys' do
+        expect(@table.itemized_changes).to eq({
+          [2,2] => 'changed'
+        })
+      end
+
+
+    end
+  end
+
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'pry'
+require 'spodunk'
+
+include Spodunk
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+
+
+
+RSpec.configure do |config|
+
+  config.filter_run_excluding skip: true 
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus => true
+
+  config.mock_with :rspec
+
+   # Use color in STDOUT
+  config.color_enabled = true
+
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # Use the specified formatter
+  config.formatter = :documentation # :progress, :html, :textmate
+
+end

data/spodunk.gemspec

@@ -0,0 +1,84 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "spodunk"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["dannguyen"]
+  s.date = "2013-12-02"
+  s.description = "Spodunk stands for \"spreadsheet\" + \"podunk\""
+  s.email = "dansonguyen@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "examples/go.rb",
+    "lib/spodunk.rb",
+    "lib/spodunk/connection.rb",
+    "lib/spodunk/connections/gdrive.rb",
+    "lib/spodunk/row.rb",
+    "lib/spodunk/table.rb",
+    "spec/lib/convenience_spec.rb",
+    "spec/lib/row_spec.rb",
+    "spec/lib/table_spec.rb",
+    "spec/spec_helper.rb",
+    "spodunk.gemspec"
+  ]
+  s.homepage = "http://github.com/dannguyen/spodunk"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "A quickie wrapper to use Google Spreadsheets as a database"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<pry>, [">= 0"])
+      s.add_runtime_dependency(%q<hashie>, [">= 0"])
+      s.add_runtime_dependency(%q<google_drive>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.2.15"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<vcr>, [">= 0"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
+      s.add_development_dependency(%q<dotenv>, [">= 0"])
+    else
+      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<hashie>, [">= 0"])
+      s.add_dependency(%q<google_drive>, [">= 0"])
+      s.add_dependency(%q<activesupport>, ["~> 3.2.15"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<vcr>, [">= 0"])
+      s.add_dependency(%q<webmock>, [">= 0"])
+      s.add_dependency(%q<dotenv>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<hashie>, [">= 0"])
+    s.add_dependency(%q<google_drive>, [">= 0"])
+    s.add_dependency(%q<activesupport>, ["~> 3.2.15"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<vcr>, [">= 0"])
+    s.add_dependency(%q<webmock>, [">= 0"])
+    s.add_dependency(%q<dotenv>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,228 @@
+--- !ruby/object:Gem::Specification
+name: spodunk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- dannguyen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: google_drive
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Spodunk stands for "spreadsheet" + "podunk"
+email: dansonguyen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- examples/go.rb
+- lib/spodunk.rb
+- lib/spodunk/connection.rb
+- lib/spodunk/connections/gdrive.rb
+- lib/spodunk/row.rb
+- lib/spodunk/table.rb
+- spec/lib/convenience_spec.rb
+- spec/lib/row_spec.rb
+- spec/lib/table_spec.rb
+- spec/spec_helper.rb
+- spodunk.gemspec
+homepage: http://github.com/dannguyen/spodunk
+licenses:
+- MIT
+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: 1249785139266135960
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A quickie wrapper to use Google Spreadsheets as a database
+test_files: []