sheets_db 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0522857a175930f3d8da223feca5a4c6c2776416
+  data.tar.gz: 8675133f8dc45b598ec153bd15a2e0929ab518ec
+SHA512:
+  metadata.gz: 829c7a9ba78e488acb5b7a53f1e73dfb8c81f0852269e20b318490dc239fe448fbf35df7cf9081f3c86cbe66f255c2ac21f7db7f8bfc8123b3bfeb3d86440fa0
+  data.tar.gz: d92a4221ac985d3075af370a7137d4ed305437d4b854b234068864a6268e61f2b37b8a81517beaf887cf5d76715d97feb1a28c0eef4430c0bf781f50074d1329

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.3.

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at ravi@ablschools.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sheets_db.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ravi Gadad
+
+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,41 @@
+# SheetsDB
+
+SheetsDB is essentially a Ruby ORM for tabular and relational data stored in Google Sheets.  While storing relational data in a spreadsheet is kind of like using a pint glass to hammer a nail, there are situations in which this can be useful, especially for prototyping or collaborating with people who aren't as comfortable seeding data into an RDBMS.
+
+There are some conventions you must follow in your Google drive folders and the Sheets themselves, but most setup of attributes, primitive type mapping, etc. is done within your object classes themselves.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sheets_db'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sheets_db
+
+## Usage
+
+View usage documentation [here](documentation/usage.md).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sheets_db. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sheets_db"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/documentation/example_models/organization.rb

@@ -0,0 +1,3 @@
+class Organization < SheetsDB::Collection
+  has_many :teams, class_name: "Team"
+end

data/documentation/example_models/pet.rb

@@ -0,0 +1,7 @@
+class Pet < SheetsDB::Worksheet::Row
+  attribute :id
+  attribute :first_name, transform: ->(first_name) { first_name.upcase }
+  attribute :favorite_colors, multiple: true
+
+  belongs_to_one :parent, from_collection: :users, foreign_key: :pet_ids
+end

data/documentation/example_models/project.rb

@@ -0,0 +1,6 @@
+class Project < SheetsDB::Spreadsheet
+  has_many :tasks, worksheet_name: "Tasks", class_name: "Task"
+  has_many :users, worksheet_name: "Users", class_name: "User"
+  has_many :pets, worksheet_name: "Pets", class_name: "Pet"
+  belongs_to_many :teams, class_name: "Team"
+end

data/documentation/example_models/task.rb

@@ -0,0 +1,10 @@
+class Task < SheetsDB::Worksheet::Row
+  attribute :id, type: Integer
+  attribute :name
+  attribute :creator_id, type: Integer
+  attribute :assignee_id, type: Integer
+  attribute :finished_at, type: DateTime
+
+  has_one :creator, from_collection: :users, key: :creator_id
+  has_one :assignee, from_collection: :users, key: :assignee_id
+end

data/documentation/example_models/team.rb

@@ -0,0 +1,8 @@
+class Team < SheetsDB::Collection
+  has_many :projects, class_name: "Project", resource_type: :spreadsheets
+  belongs_to_many :organizations, class_name: "Organization"
+
+  def organization
+    organizations.first
+  end
+end

data/documentation/example_models/user.rb

@@ -0,0 +1,10 @@
+class User < SheetsDB::Worksheet::Row
+  attribute :id, type: Integer
+  attribute :first_name
+  attribute :last_name
+  attribute :pet_ids, multiple: true
+
+  has_many :pets, from_collection: :pets, key: :pet_ids
+
+  belongs_to_many :created_tasks, from_collection: :tasks, foreign_key: :creator_id
+end

data/documentation/usage.md

@@ -0,0 +1,184 @@
+# SheetsDB
+
+## Usage
+
+**NOTE**: Currently, SheetsDB only supports reading and updating entities within Google Drive and Sheets; adding new entities or deleting existing ones is not available yet.  Also, updating is restricted to worksheet rows, so folders and spreadsheets are not yet renamable using SheetsDB.
+
+### The Data Model
+
+For the sake of documentation, we'll set up an example data model that looks like the following:
+
+![](images/example_erd.png)
+
+SheetsDB works with several layers of the hierarchy in Google Sheets and Drive (within a worksheet, across worksheets in a Sheet, and across folders in Drive).  We'll briefly go over each of these, and then later we'll dive more deeply.
+
+#### Worksheets
+
+Worksheets are the best analog we have to database tables - they contain rows, and we can use one of the rows as a header to establish columns.  In SheetsDB, a worksheet is the only way we can represent arbitrary tabular data (outside of relationships that map directly to the folder and file structure in Google Drive).  Therefore, for the example above, we'll need to use worksheets to describe the `Task`, `User`, and `Pet` models.
+
+#### Spreadsheets
+
+All worksheets live in a spreadsheet, and there is no way to access a worksheet or its rows outside of the spreadsheet context.  Therefore, there will always be a single parent relationship from the worksheet-based models to a spreadsheet-based model, in this case `Project`.  Note that we can't persist any arbitrary metadata at the project level in this example - if we needed to, `Project` would need to become a worksheet-based model.  Within the spreadsheet, worksheets can contain rows having relationships to rows in other worksheets.
+
+#### Folders
+
+Folders can contain spreadsheets, other folders, or both (obviously Drive folders can also contain other types of files, but SheetsDB ignores these).  They inherently have a zero-to-many relationship with subfolders or any number of spreadsheets, and also (unless they are root folders) can have a one-to-many relationship to parent folders.  Therefore, `Organization` and `Team` will both be folder-based models.
+
+Note that subfolders within a folder-based model must all be the same type - there is no support for different kinds of subfolder relationships from a single folder type.  For example, in the data model we're working with, we couldn't have some subfolders of an `Organization` folder be `Team` folders while others were "`Building`" folders.  The same goes for spreadsheets within a folder-based model - only one spreadsheet type relationship is possible.
+
+You *can*, however, have a single type of subfolder relationship and also a single type of spreadsheet relationship.  In the example above, that would mean a `Team` folder could have many spreadsheets, which would all have to be set up as `Project` spreadsheets; but also many subfolders, which would all have to be set up as the same kind of folder-based model.
+
+### Setting Up the Structure in Google Drive
+
+To create the structures in Google Drive to represent our example data model, we'll start at the top and work our way down the hierarchy.
+
+#### Folders
+
+First, go into your Google Drive account and create a new folder that will represent the top of our hierarchy.  It doesn't matter where you create this folder, since we'll reference it directly by its id within Google Drive; it can be at the root, or deep within nested folders.  Let's call this folder "Organization A" (though the folder name is meaningless); we'll map this to an `Organization` instance in SheetsDB.
+
+Since our data model specifies that an `Organization` has zero-to-many `Team`s, and `Team` is a folder-based model, all subfolders in our new folder will represent teams.  Navigate into the "Organization A" folder and create two new folders: "Team Alpha" and "Team Bravo".  We're creating two just to demonstrate the subfolder relationship, but we'll work only in "Team Alpha" for now.
+
+#### Spreadsheets
+
+Navigate into the "Team Alpha" folder.  This folder represents a `Team` in our data model, and `Team`s have many `Project`s.  A `Project` is a spreadsheet-based model, so let's create a new Google Sheets spreadsheet in this folder.  Name your new empty spreadsheet "Test Project 1".  Later, when you want to create a new `Project`, you'll go back into one of your `Team` folders and create a new spreadsheet there; for now, we'll just use a single `Project` spreadsheet.
+
+#### Worksheets
+
+Now we get to the fun part - representing tabular data and relationships between worksheets.  In our data model, a `Project` has three child relationships - `Task`s, `User`s, and `Pet`s.  Therefore, let's create three worksheets.  What you name these worksheets is flexible and doesn't have to be the same as the relationship name, but obviously it'll be less confusing to map them semantically.  So let's call the three worksheets "Tasks", "Users", and "Pets".
+
+Within the "Tasks" worksheet, set up a header row with each cell being one of the `Task` column names from our data model (`id`, `name`, `creator_id`, `assignee_id`, and `finished_at`).  Repeat this for the "Users" worksheet with `User` columns (`id`, `first_name`, `last_name`, and `pet_ids`), and the "Pets" worksheet with `Pet` columns (`id`, `first_name`, and `favorite_colors`).
+
+Now let's fill in some dummy data.  Make sure any entries in association columns (like `creator_id` and `pet_ids`) reference the `id` column in their respective child worksheets.  For multiple value columns (`pet_ids` and `favorite_colors`), use a comma-separated list of values (__currently, values that contain commas themselves aren't supported - we'll add escaping in a later version__).
+
+When you're done, your spreadsheet should look similar to the following:
+
+![](images/example_spreadsheet_data.png)
+
+**A few things to note:**
+
+1. Empty cells will result in null values.  Blank string values are currently not supported in any way.
+2. The `finished_at` column actually represents a date & time in Google Sheets and not an arbitrary string field; you can confirm this by highlighting one of those cells and seeing the value in the formula bar.  If you want to use a column as a Ruby `DateTime` in SheetsDB, make sure the actual data is formatted as `%m/%d/%Y %H:%M:%S` (single digit months and days are acceptable).
+3. In comma-separated lists of values, spaces after commas are ignored, so "1, 2,  3" works just as well as "1,2,3".
+
+### Accessing the Data
+
+Now that we're done entering all our data, let's set up our models in Ruby so we can start reading and updating this data.  All the example model classes below are also in the [examples](example_models) directory.
+
+#### Creating a Session
+
+To access your files in Google Drive, you need to start by creating a SheetsDB::Session.  This is done by wrapping a GoogleDrive::Session.  There are several ways to do this, all described in the `google_drive` gem's documentation [here](https://github.com/gimite/google-drive-ruby/blob/master/doc/authorization.md).  Note that the GoogleDrive gem is already available to you if you're using SheetsDB, as it is a loaded dependency.
+
+Once you have a GoogleDrive::Session, create a SheetsDB::Session using it:
+
+```ruby
+google_drive_session = GoogleDrive::Session.from_config("config.json")
+sheets_db_session = SheetsDB::Session.new(google_drive_session)
+```
+
+You'll then use this session when fetching Sheets or folders from Google Drive, by id:
+
+```ruby
+# in this example, Organization is a class inheriting from SheetsDB::Collection
+Organization.find_by_id("b3FeFCg3p-IyjdL27crOR", session: sheets_db_session)
+```
+
+However, in cases where you're using a single session for all your requests to Drive (for example, if you're using a service account rather than OAuth), you can set an instance of SheetsDB::Session as your default, and that default will be used for your requests until it's changed or the class is reloaded.
+
+```ruby
+SheetsDB::Session.default = sheets_db_session
+Organization.find_by_id("b3FeFCg3p-IyjdL27crOR")
+```
+
+Make sure the user or service account you've authenticated as, in your session, has access to the folder hierarchy we created earlier.
+
+Great, now we have a session and we can fetch resources from Google Drive!
+
+#### Folder Models
+
+Model classes representing folders should inherit from `SheetsDB::Collection`, and can have relationships to subfolders using the `has_many` class method.  Here is our `Organization` class:
+
+```ruby
+class Organization < SheetsDB::Collection
+  has_many :teams, class_name: "Team"
+end
+```
+
+Our `Team` class is similar, but specifies that `Project` children are spreadsheets (instead of subfolders), and also uses the `belongs_to_many` method to define the parent relationship to `Organization`.  Note that there is no way to restrict a folder or file's parent structure to allow only one parent; therefore, there is no `belongs_to_one` method.  If you know your structure will only ever have a single parent for a given resource, you could set up a method to access the first element of this collection, as we've done in the `Team` class:
+
+```ruby
+class Team < SheetsDB::Collection
+  has_many :projects, class_name: "Project", resource_type: :spreadsheets
+  belongs_to_many :organizations, class_name: "Organization"
+
+  def organization
+    organizations.first
+  end
+end
+```
+
+#### Spreadsheet Models
+
+The `Project` model uses a different base class (`SheetsDB::Spreadsheet`).  From this type of model class, the `has_many` method references worksheets instead of subfolders or spreadsheets, so it has a different signature:
+
+```ruby
+class Project < SheetsDB::Spreadsheet
+  has_many :tasks, worksheet_name: "Tasks", class_name: "Task"
+  has_many :users, worksheet_name: "Users", class_name: "User"
+  has_many :pets, worksheet_name: "Pets", class_name: "Pet"
+  belongs_to_many :teams, class_name: "Team"
+end
+```
+
+#### Worksheet Row Models
+
+Finally, we get to the worksheets.  We're not trying to model the worksheets themselves - those are analogous to the schema of a table.  What we're modeling is rows within the worksheets, so each of these models will inherit from `SheetsDB::Worksheet::Row`.  We'll need to specify what the attributes are, to set up accessor methods and to specify their types; we'll also be setting up relationships to other worksheet models.  Here are the three models:
+
+```ruby
+class Task < SheetsDB::Worksheet::Row
+  attribute :id, type: Integer
+  attribute :name
+  attribute :creator_id, type: Integer
+  attribute :assignee_id, type: Integer
+  attribute :finished_at, type: DateTime
+
+  has_one :creator, from_collection: :users, key: :creator_id
+  has_one :assignee, from_collection: :users, key: :assignee_id
+end
+
+class User < SheetsDB::Worksheet::Row
+  attribute :id, type: Integer
+  attribute :first_name
+  attribute :last_name
+  attribute :pet_ids, multiple: true
+
+  has_many :pets, from_collection: :pets, key: :pet_ids
+
+  belongs_to_many :created_tasks, from_collection: :tasks, foreign_key: :creator_id
+end
+
+class Pet < SheetsDB::Worksheet::Row
+  attribute :id
+  attribute :first_name, transform: ->(first_name) { first_name.upcase }
+  attribute :favorite_colors, multiple: true
+
+  belongs_to_one :parent, from_collection: :users, foreign_key: :pet_ids
+end
+```
+
+##### The Attribute Method
+
+The only required argument to the `attribute` class method is the name of the column itself.  All other options are optional:
+
+`type`: The `attribute` method currently supports three types: `Integer`, `DateTime`, and the default `String`.  Any other value given to the `type` option will be ignored and the default will be used.
+
+`multiple`: This option defaults to false.  If true, it tells SheetsDB to parse the value as a comma-separated list of values, and return an array by splitting on the comma (if no comma is found, it will return a single element array).
+
+`transform`: If you supply a Proc (or lambda) to the `transform` option, reading this column from the spreadsheet will cause it to first be sent through this transformation Proc.  For `multiple` columns, each element will be transformed independently.
+
+##### `has_many` and `has_one` associations
+
+For associations in which the key exists in the specifying row, use `has_many` or `has_one`.  The `from_collection` parameter should reference the `has_many` entry on the Spreadsheet model that maps to the target worksheet, and the `key` parameter is the name of the local column that maps to the foreign worksheet's `id` column.
+
+##### `belongs_to_many` and `belongs_to_one` associations
+
+For associations in which the key exists in the foreign row, use `belongs_to_many` or `belongs_to_one`.  The `from_collection` parameter should reference the `has_many` entry on the Spreadsheet model that maps to the target worksheet, and the `foreign_key` parameter is the name of the foreign worksheet's column that maps to the local worksheet's `id` column.

data/lib/sheets_db/collection.rb

@@ -0,0 +1,18 @@
+module SheetsDB
+  class Collection < Resource
+    set_resource_type GoogleDrive::Collection
+
+    def self.has_many(resource, class_name:, resource_type: :subcollections)
+      unless [:subcollections, :spreadsheets].include?(resource_type)
+        raise ArgumentError, "resource_type must be :subcollections or :spreadsheets"
+      end
+      register_association(resource, class_name: class_name, resource_type: resource_type)
+      define_method(resource) do
+        result = instance_variable_get(:"@#{resource}")
+        result || instance_variable_set(:"@#{resource}",
+          google_drive_resource.send(resource_type).map { |raw| Support.constantize(class_name).new(raw) }
+        )
+      end
+    end
+  end
+end

data/lib/sheets_db/resource.rb

@@ -0,0 +1,68 @@
+module SheetsDB
+  class Resource
+    class ResourceTypeMismatchError < StandardError; end
+    class CollectionTypeAlreadyRegisteredError < StandardError; end
+
+    class << self
+      attr_reader :resource_type
+
+      def set_resource_type(resource_type)
+        @resource_type = resource_type
+      end
+
+      def find_by_id(id, session: SheetsDB::Session.default)
+        google_drive_resource = session.raw_file_by_id(id)
+        if @resource_type && !google_drive_resource.is_a?(@resource_type)
+          fail(ResourceTypeMismatchError, "The file with id #{id} is not a #{@resource_type}")
+        end
+        new(google_drive_resource)
+      end
+
+      def belongs_to_many(resource, class_name:)
+        register_association(resource, class_name: class_name, resource_type: :parents)
+        define_method(resource) do
+          result = instance_variable_get(:"@#{resource}")
+          result || instance_variable_set(:"@#{resource}",
+            google_drive_resource.parents.map { |id| Support.constantize(class_name).find_by_id(id) }
+          )
+        end
+      end
+
+      def register_association(resource, class_name:, resource_type:)
+        @associations ||= {}
+        if @associations.values.any? { |value| value[:resource_type] == resource_type }
+          raise CollectionTypeAlreadyRegisteredError
+        end
+        @associations[resource] = {
+          resource_type: resource_type,
+          class_name: class_name
+        }
+      end
+    end
+
+    extend Forwardable
+    def_delegators :google_drive_resource, :id, :name
+    def_delegator :google_drive_resource, :created_time, :created_at
+    def_delegator :google_drive_resource, :modified_time, :updated_at
+
+    attr_reader :google_drive_resource
+
+    def initialize(google_drive_resource)
+      @google_drive_resource = google_drive_resource
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        other.google_drive_resource == google_drive_resource
+    end
+
+    def base_attributes
+      {
+        id: id,
+        name: name,
+        created_at: created_at,
+        updated_at: updated_at
+      }
+    end
+  end
+end

data/lib/sheets_db/session.rb

@@ -0,0 +1,34 @@
+require "google_drive"
+
+module SheetsDB
+  class Session
+    class IllegalDefaultError < StandardError; end
+    class NoDefaultSetError < StandardError; end
+
+    def self.default=(default)
+      unless default.is_a?(self)
+        raise IllegalDefaultError.new("Default must be a SheetsDB::Session")
+      end
+      @default = default
+    end
+
+    def self.default
+      unless @default
+        raise NoDefaultSetError.new("No default Session defined yet")
+      end
+      @default
+    end
+
+    def self.from_service_account_key(*args)
+      new(GoogleDrive::Session.from_service_account_key(*args))
+    end
+
+    def initialize(google_drive_session)
+      @google_drive_session = google_drive_session
+    end
+
+    def raw_file_by_id(id)
+      @google_drive_session.file_by_id(id)
+    end
+  end
+end

data/lib/sheets_db/spreadsheet.rb

@@ -0,0 +1,46 @@
+module SheetsDB
+  class Spreadsheet < Resource
+    class WorksheetAssociationAlreadyRegisteredError < StandardError; end
+
+    set_resource_type GoogleDrive::Spreadsheet
+
+    def self.has_many(resource, worksheet_name:, class_name:)
+      register_worksheet_association(resource, worksheet_name: worksheet_name, class_name: class_name)
+      define_method(resource) do
+        @worksheets ||= {}
+        @worksheets[resource] ||= Worksheet.new(
+          spreadsheet: self,
+          google_drive_resource: google_drive_resource.worksheet_by_title(worksheet_name),
+          type: Support.constantize(class_name)
+        )
+      end
+    end
+
+    def self.register_worksheet_association(resource, worksheet_name:, class_name:)
+      @associations ||= {}
+      if @associations.fetch(resource, nil)
+        raise WorksheetAssociationAlreadyRegisteredError
+      end
+      @associations[resource] = {
+        worksheet_name: worksheet_name,
+        class_name: class_name
+      }
+    end
+
+    def find_association_by_id(association_name, id)
+      find_associations_by_ids(association_name, [id]).first
+    end
+
+    def find_associations_by_ids(association_name, ids)
+      send(association_name).find_by_ids(ids)
+    end
+
+    def find_associations_by_attribute(association_name, attribute_name, value)
+      send(association_name).find_by_attribute(attribute_name, value)
+    end
+
+    def select_from_association(association_name, &block)
+      send(association_name).select(&block)
+    end
+  end
+end

data/lib/sheets_db/support.rb

@@ -0,0 +1,22 @@
+module SheetsDB
+  module Support
+    class << self
+      def camelize(string)
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+        string = string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+      end
+
+      def constantize(string)
+        name_parts = camelize(string).split('::')
+        name_parts.shift if name_parts.first.empty?
+        constant = Object
+
+        name_parts.each do |name_part|
+          constant_defined = constant.const_defined?(name_part, false)
+          constant = constant_defined ? constant.const_get(name_part) : constant.const_missing(name_part)
+        end
+        constant
+      end
+    end
+  end
+end

data/lib/sheets_db/version.rb

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

data/lib/sheets_db/worksheet/column.rb

@@ -0,0 +1,18 @@
+module SheetsDB
+  class Worksheet
+    class Column
+      attr_reader :name, :column_position
+
+      def initialize(name:, column_position:)
+        @name = name
+        @column_position = column_position
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          other.name == name &&
+          other.column_position == column_position
+      end
+    end
+  end
+end

data/lib/sheets_db/worksheet/row.rb

@@ -0,0 +1,221 @@
+module SheetsDB
+  class Worksheet
+    class Row
+      class AttributeAlreadyRegisteredError < StandardError; end
+      class AssociationAlreadyRegisteredError < StandardError; end
+
+      class << self
+        attr_reader :association_definitions
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@attribute_definitions, @attribute_definitions)
+          subclass.instance_variable_set(:@association_definitions, @association_definitions)
+        end
+
+        def attribute(name, type: String, multiple: false, transform: nil)
+          register_attribute(name, type: type, multiple: multiple, transform: transform, association: false)
+
+          define_method(name) do
+            begin
+              get_modified_attribute(name)
+            rescue KeyError
+              get_persisted_attribute(name)
+            end
+          end
+
+          define_method("#{name}=") do |value|
+            stage_attribute_modification(name, value)
+          end
+        end
+
+        def has_association(name, from_collection:, key:, multiple: false)
+          register_attribute(name, from_collection: from_collection, key: key, multiple: multiple, association: true)
+
+          define_method(name) do
+            @loaded_associations[name] ||= begin
+              response = spreadsheet.find_associations_by_ids(from_collection, Array(send(key)))
+              multiple ? response : response.first
+            end
+          end
+
+          define_method("#{name}=") do |value|
+            assignment_value = multiple ? value.map(&:id) : value.id
+            send("#{key}=", assignment_value)
+            @loaded_associations[name] = value
+          end
+        end
+
+        def has_one(name, from_collection:, key:)
+          has_association(name, from_collection: from_collection, key: key, multiple: false)
+        end
+
+        def has_many(name, from_collection:, key:)
+          has_association(name, from_collection: from_collection, key: key, multiple: true)
+        end
+
+        def belongs_to_association(name, from_collection:, foreign_key:, multiple: false)
+          register_attribute(name, from_collection: from_collection, foreign_key: foreign_key, multiple: multiple, association: true)
+
+          define_method(name) do
+            @loaded_associations[name] ||= begin
+              response = spreadsheet.find_associations_by_attribute(from_collection, foreign_key, id)
+              multiple ? response : response.first
+            end
+          end
+
+          define_method("#{name}=") do |value|
+            existing_values = Array(send(name))
+            Array(value).each do |foreign_item|
+              next if existing_values.delete(foreign_item)
+              foreign_item.add_element_to_attribute(foreign_key, id)
+              @changed_foreign_items << foreign_item
+            end
+            existing_values.each do |existing_foreign_item|
+              existing_foreign_item.remove_element_from_attribute(foreign_key, id)
+              @changed_foreign_items << existing_foreign_item
+            end
+            @loaded_associations[name] = value
+          end
+        end
+
+        def belongs_to_one(name, from_collection:, foreign_key:)
+          belongs_to_association(name, from_collection: from_collection, foreign_key: foreign_key, multiple: false)
+        end
+
+        def belongs_to_many(name, from_collection:, foreign_key:)
+          belongs_to_association(name, from_collection: from_collection, foreign_key: foreign_key, multiple: true)
+        end
+
+        def register_attribute(name, **options)
+          if attribute_definitions.fetch(name, nil)
+            raise AttributeAlreadyRegisteredError, name
+          end
+          attribute_definitions[name] = options
+        end
+
+        def attribute_definitions
+          @attribute_definitions ||= {}
+        end
+      end
+
+      attr_reader :worksheet, :row_position, :loaded_attributes, :loaded_associations, :changed_foreign_items
+
+      def initialize(worksheet:, row_position:)
+        @worksheet = worksheet
+        @row_position = row_position
+        @loaded_attributes = {}
+        @loaded_associations = {}
+        @changed_foreign_items = []
+      end
+
+      def get_modified_attribute(name)
+        loaded_attributes.fetch(name, {}).
+          fetch(:changed)
+      end
+
+      def get_persisted_attribute(name)
+        loaded_attributes[name] ||= {}
+        loaded_attributes[name][:original] ||=
+          worksheet.attribute_at_row_position(name, row_position)
+      end
+
+      def stage_attribute_modification(name, value)
+        loaded_attributes[name] ||= {}
+        loaded_attributes[name][:changed] = value
+      end
+
+      def modify_collection_attribute(name, value, remove:)
+        attribute_definition = self.class.attribute_definitions.fetch(name, {})
+        existing_value = Array(send(name))
+        return if remove && !existing_value.include?(value)
+        return if !remove && existing_value.include?(value)
+        assignment_value = if attribute_definition[:multiple]
+          remove ? existing_value - [value] : existing_value.concat([value])
+        else
+          remove ? nil : value
+        end
+        send("#{name}=", assignment_value)
+      end
+
+      def add_element_to_attribute(name, value)
+        modify_collection_attribute(name, value, remove: false)
+      end
+
+      def remove_element_from_attribute(name, value)
+        modify_collection_attribute(name, value, remove: true)
+      end
+
+      def reload!
+        worksheet.reload!
+        reset_attributes_and_associations_cache
+      end
+
+      def save!
+        worksheet.update_attributes_at_row_position(staged_attributes, row_position: row_position)
+        save_changed_foreign_items!
+        reset_attributes_and_associations_cache
+      end
+
+      def save_changed_foreign_items!
+        changed_foreign_items.each do |foreign_item|
+          foreign_item.save!
+        end
+      end
+
+      def reset_attributes_and_associations_cache
+        @loaded_attributes = {}
+        @loaded_associations = {}
+      end
+
+      def staged_attributes
+        loaded_attributes.each_with_object({}) { |(key, value), hsh|
+          next unless value
+          hsh[key] = value[:changed] if value[:changed]
+          hsh
+        }
+      end
+
+      def spreadsheet
+        worksheet.spreadsheet
+      end
+
+      def attributes
+        get_all_attributes do |options|
+          !options.fetch(:association, false)
+        end
+      end
+
+      def associations
+        get_all_attributes do |options|
+          options.fetch(:association, false)
+        end
+      end
+
+      def get_all_attributes(&block)
+        self.class.attribute_definitions.each_with_object({}) { |(name, options), memo|
+          memo[name] = send(name) if block.call(options)
+          memo
+        }
+      end
+
+      def to_hash(depth: 0)
+        hashed_associations = if depth > 0
+          Hash[
+            associations.map { |name, association|
+              association_hash = if association.is_a?(Array)
+                association.map { |item| item.to_hash(depth: depth - 1) }
+              else
+                association.to_hash(depth: depth - 1)
+              end
+              [name, association_hash]
+            }
+          ]
+        else
+          {}
+        end
+        attributes.merge(hashed_associations)
+      end
+    end
+  end
+end

data/lib/sheets_db/worksheet.rb

@@ -0,0 +1,124 @@
+require_relative "worksheet/column"
+require_relative "worksheet/row"
+
+module SheetsDB
+  class Worksheet
+    include Enumerable
+
+    attr_reader :spreadsheet, :google_drive_resource, :type
+
+    def initialize(spreadsheet:, google_drive_resource:, type:)
+      @spreadsheet = spreadsheet
+      @google_drive_resource = google_drive_resource
+      @type = type
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        other.google_drive_resource == google_drive_resource &&
+        other.type == type
+    end
+
+    def columns
+      @columns ||= begin
+        {}.tap { |directory|
+          google_drive_resource.rows.first.each_with_index do |name, i|
+            unless name == ""
+              directory[name.to_sym] = Column.new(name: name.to_sym, column_position: i + 1)
+            end
+          end
+        }
+      end
+    end
+
+    def attribute_definitions
+      type.attribute_definitions
+    end
+
+    def attribute_at_row_position(column_name, row_position)
+      attribute_definition = attribute_definitions.fetch(column_name, {})
+      column = columns[column_name]
+      raw_value = read_value_from_google_drive_resource(
+        dimensions: [row_position, column.column_position],
+        attribute_definition: attribute_definition
+      )
+    end
+
+    def read_value_from_google_drive_resource(dimensions:, attribute_definition:)
+      raw_value = case attribute_definition[:type].to_s
+        when "DateTime"
+          google_drive_resource.input_value(*dimensions)
+        else
+          google_drive_resource[*dimensions]
+      end
+      if attribute_definition[:multiple]
+        raw_value.split(/,\s*/).map { |value| convert_value(value, attribute_definition) }
+      else
+        convert_value(raw_value, attribute_definition)
+      end
+    end
+
+    def update_attributes_at_row_position(staged_attributes, row_position:)
+      staged_attributes.each do |name, value|
+        column = columns[name]
+        definition = attribute_definitions[name]
+        assignment_value = definition[:multiple] ? value.join(",") : value
+        google_drive_resource[row_position, column.column_position] = assignment_value
+      end
+      google_drive_resource.synchronize
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+      (google_drive_resource.num_rows - 1).times do |i|
+        yield type.new(worksheet: self, row_position: i + 2)
+      end
+    end
+
+    def all
+      to_a
+    end
+
+    def find_by_id(id)
+      find_by_ids([id]).first
+    end
+
+    def find_by_ids(ids)
+      result = []
+      each do |model|
+        break if result.count == ids.count
+        if ids.include?(model.id)
+          result << model
+        end
+      end
+      result
+    end
+
+    def find_by_attribute(attribute_name, value)
+      definition = attribute_definitions[attribute_name]
+      select { |item|
+        attribute = item.send(attribute_name)
+        definition[:multiple] ? attribute.include?(value) : attribute == value
+      }
+    end
+
+    def reload!
+      google_drive_resource.reload
+    end
+
+    def convert_value(raw_value, attribute_definition)
+      return nil if raw_value == ""
+      converted_value = case attribute_definition[:type].to_s
+      when "Integer"
+        raw_value.to_i
+      when "DateTime"
+        DateTime.strptime(raw_value, "%m/%d/%Y %H:%M:%S")
+      else
+        raw_value
+      end
+      attribute_definition[:transform] ?
+        attribute_definition[:transform].call(converted_value) :
+        converted_value
+    end
+  end
+end

data/lib/sheets_db.rb

@@ -0,0 +1,11 @@
+require "sheets_db/version"
+require "sheets_db/support"
+require "sheets_db/session"
+require "sheets_db/resource"
+require "sheets_db/collection"
+require "sheets_db/spreadsheet"
+require "sheets_db/worksheet"
+
+module SheetsDB
+  # Your code goes here...
+end

data/sheets_db.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sheets_db/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sheets_db"
+  spec.version       = SheetsDB::VERSION
+  spec.authors       = ["Ravi Gadad"]
+  spec.email         = ["ravi@ablschools.com"]
+
+  spec.summary       = %q{Adapter for pseudo-relational data stored in Google Sheets}
+  spec.homepage      = "https://github.com/ablschools/sheets_db"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "google_drive", "~> 2.1"
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: sheets_db
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ravi Gadad
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google_drive
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- ravi@ablschools.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- documentation/example_models/organization.rb
+- documentation/example_models/pet.rb
+- documentation/example_models/project.rb
+- documentation/example_models/task.rb
+- documentation/example_models/team.rb
+- documentation/example_models/user.rb
+- documentation/images/example_erd.png
+- documentation/images/example_spreadsheet_data.png
+- documentation/usage.md
+- lib/sheets_db.rb
+- lib/sheets_db/collection.rb
+- lib/sheets_db/resource.rb
+- lib/sheets_db/session.rb
+- lib/sheets_db/spreadsheet.rb
+- lib/sheets_db/support.rb
+- lib/sheets_db/version.rb
+- lib/sheets_db/worksheet.rb
+- lib/sheets_db/worksheet/column.rb
+- lib/sheets_db/worksheet/row.rb
+- sheets_db.gemspec
+homepage: https://github.com/ablschools/sheets_db
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Adapter for pseudo-relational data stored in Google Sheets
+test_files: []