airmodel 0.0.1pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 52609d17520965802a5ce6ad3bfbd4ed9e16d1bc
+  data.tar.gz: a2aa97650c28a577de2a568827ef8e52ab502004
+SHA512:
+  metadata.gz: 1cb44df1db02298370724c4245548cb0dc52f49700efa0a8946c255b3aeaf9603912a1f4b7d451a8273a03927b31382714453e54b7a41981f5d60f447b005ef1
+  data.tar.gz: 7b8a4704f3679579fc8f0324f6a6f66a4764b47770843ae8a20d56898699eb535b8d608146ed0834fc48893d00ce1612619af13bf7102349b9d3ffc2324ebba0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,81 @@
+Airmodel
+===========
+
+Interact with your Airtable data using ActiveRecord-style models.
+
+Installation
+----------------
+
+Add this line to your Gemfile:
+
+		gem install 'airmodel', git: 'https://github.com/chrisfrank/airmodel.git'
+
+Configuration
+----------------
+1. Supply your Airtable API key, either by setting ENV['AIRTABLE_API_KEY']
+before your app starts...
+
+		ENV['AIRTABLE_API_KEY'] = YOUR_API_KEY
+
+	... or by putting this line somewhere in your app's init block:
+
+		Airmodel.client(YOUR_API_KEY_HERE)
+
+2. Tell Airmodel where your bases are, either by creating a YAML file at
+*config/bases.yml*, or with this line somewhere in your init block:
+
+		Airmodel.bases(path_to_your_yaml_file)
+
+	Your YAML file should look something like this:
+
+		:songs:
+			:table_name: Songs
+			:bases: appXYZ123ABC
+		:albums:
+			:table_name: Albums
+			:bases: appZZTOPETC
+
+	Airmodel supports sharding your data across multiple Airtable bases, as long as
+they all have the same structure. If you've split your customers into east- and
+west-coast bases, for example, your YAML file should look like this:
+
+		:songs:
+			:table_name: Customers
+			:bases:
+				"east_coast": appXYZ123ABC
+				"west_coast": appWXYOMGWTF
+
+Usage
+----------------
+
+Create a class for each key in your YAML file. You should name it after the 
+singularized version of your YAML key:
+
+		class Song < Airmodel::Model
+		end
+
+		class Album < Airmodel::Model
+		end
+
+Now you can write code like
+
+		Song.all
+
+		Song.first
+
+		Song.new("Name": "Best Song Ever").save
+
+		Song.where("Artist Name": "The Beatles", "Composer": "Harrison")
+
+See lib/airmodel/model.rb for all available methods.
+
+
+Contributions
+----------------
+
+Add a test to spec/models_spec.rb, make sure it passes, then send a pull
+request. Thanks!
+
+
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('spec/*_spec.rb')
+  t.rspec_opts = '--format documentation'
+end
+task :default => :spec

data/airmodel.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'airmodel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'airmodel'
+  spec.version       = Airmodel::VERSION
+  spec.authors       = ['chrisfrankdotfm']
+  spec.email         = ['chris.frank@thefutureproject.org']
+  spec.description   = 'Airtable data in ActiveRecord-style syntax'
+  spec.summary       = 'Interact with your Airtable data using ActiveRecord-style models'
+  spec.homepage      = 'https://github.com/chrisfrank/airmodel'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep('^(test|spec|features)/')
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1'
+  spec.add_development_dependency 'rake', '~> 10'
+  spec.add_development_dependency 'rspec', '~> 3'
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'fakeweb', '~> 1.3'
+
+  spec.add_dependency 'airtable', '~> 0.0.8'
+  spec.add_dependency 'activesupport', '~> 5.0'
+end

data/config/bases.yml

@@ -0,0 +1,8 @@
+:test_models:
+  :table_name: "example_table"
+  :bases: appXYZ
+:sharded_test_models:
+  :table_name: "example_table"
+  :bases:
+    "nyc": appLGA
+    "sf": appSFO

data/lib/airmodel.rb

@@ -0,0 +1,44 @@
+require 'active_support/all'
+require 'airtable'
+
+require "airmodel/version"
+require "airmodel/utils"
+require "airmodel/model"
+
+# builds ActiveRecord-style models on top of Airtable
+module Airmodel
+
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+
+  def self.client(api_key=ENV["AIRTABLE_API_KEY"])
+    @@api_client ||= Airtable::Client.new(api_key)
+    @@api_client
+  end
+
+  def self.bases(path_to_config_file="#{Airmodel.root}/config/bases.yml")
+    @@bases ||= YAML.load_file(path_to_config_file)
+    @@bases
+  end
+
+end
+
+# monkeypatch airtable-ruby to add v 0.0.9's PATCH method,
+# at least until Airtable adds 0.0.9 to rubygems
+module Airtable
+  class Table
+
+    def update_record_fields(record_id, fields_for_update)
+      result = self.class.patch(worksheet_url + "/" + record_id,
+        :body => { "fields" => fields_for_update }.to_json,
+        :headers => { "Content-type" => "application/json" }).parsed_response
+      if result.present? && result["id"].present?
+        Record.new(result_attributes(result))
+      else # failed
+        false
+      end
+    end
+
+  end
+end

data/lib/airmodel/model.rb

@@ -0,0 +1,153 @@
+module Airmodel
+  class Model < Airtable::Record
+    extend Utils
+
+    # returns all records in the database, making as many calls as necessary
+    # to work around Airtable's 100-record per page design
+    def self.all(args={sort: default_sort})
+      puts "RUNNING EXPENSIVE API QUERY TO AIRTABLE (#{self.name})"
+      self.classify tables(args).map{|tbl| tbl.all(args)}.flatten
+    end
+
+    # returns up to 100 records from Airtable
+    def self.records(args={sort: default_sort})
+      puts "RUNNING EXPENSIVE API QUERY TO AIRTABLE (#{self.name})"
+      self.classify tables(args).map{|tbl| tbl.records(args) }.flatten
+    end
+
+    # default to whatever order airtable returns
+    # this method gets overridden on Airtabled classes
+    def self.default_sort
+      nil
+    end
+
+    # find records that match the filters
+    def self.where(filters)
+      shard = filters.delete(:shard)
+      order = filters.delete(:sort)
+      formula = "AND(" + filters.map{|k,v| "{#{k}}='#{v}'" }.join(',') + ")"
+      records(
+        shard: shard,
+        sort: order,
+        filterByFormula: formula,
+      )
+    end
+
+    # find a record by specified attributes, return it
+    def self.find_by(filters)
+      shard = filters.delete(:shard)
+      if filters[:id]
+        results = self.classify tables(shard: shard).map{|tbl| tbl.find(filters[:id]) }
+      else
+        formula = "AND(" + filters.map{|k,v| "{#{k}}='#{v}'" }.join(',') + ")"
+        results = records(
+          shard: shard,
+          filterByFormula: formula,
+          limit: 1
+        )
+      end
+      results.count == 0 ? nil : results.first
+    end
+
+    # return the first record
+    def self.first
+      results = records(
+        limit: 1
+      )
+      results.count == 0 ? nil : results.first
+    end
+
+    # create a new record and save it to Airtable
+    def self.create(*records)
+      results = records.map{|r|
+        record = self.new(r)
+        tables.map{|tbl| tbl.create(record) }.first
+      }
+      results.length == 1 ? results.first : results
+    end
+
+    # send a PATCH request to update a few fields on a record in one API call
+    def self.patch(id, fields, shard=nil)
+      r = tables(shard: shard).map{|tbl|
+        tbl.update_record_fields(id, airtable_formatted(fields))
+      }.first
+      self.new(r.fields)
+    end
+
+    # INSTANCE METHODS
+
+    def formatted_fields
+      self.class.airtable_formatted(self.fields)
+    end
+
+    def save(shard=self.shard_identifier)
+      if self.valid?
+        if new_record?
+          results = self.class.tables(shard: shard).map{|tbl|
+            tbl.create self
+          }
+          # return the first version of this record that saved successfully
+          results.find{|x| !!x }
+        else
+          results = self.class.tables(shard: shard).map{|tbl|
+            tbl.update_record_fields(id, self.changed_fields)
+          }
+          results.find{|x| !!x }
+        end
+      else
+        false
+      end
+    end
+
+    def changed_fields
+      current = fields
+      old = self.class.find_by(id: id, shard: shard_identifier).fields
+      self.class.hash_diff(current, old)
+    end
+
+    def destroy
+      self.class.tables(shard: shard_identifier).map{|tbl| tbl.destroy(id) }.first
+    end
+
+    def update(fields)
+      res = self.class.tables(shard: shard_identifier).map{|tbl| tbl.update_record_fields(id, fields) }.first
+      res.fields.each{|field, value| self[field] = value }
+      true
+    end
+
+    def new_record?
+      id.nil?
+    end
+
+    def cache_key
+      "#{self.class.table_name}_#{self.id}"
+    end
+
+    # override if you want to write server-side model validations
+    def valid?
+      true
+    end
+
+    # override if you want to return validation errors
+    def errors
+      {}
+    end
+
+    # getter method that should return the YAML key that defines
+    # which shard the record lives in. Override if you're sharding
+    # your data, otherwise just let it return nil
+    def shard_identifier
+      nil
+    end
+
+  end
+
+  # raise this error when a table
+  # is not defined in config/airtable_data.yml
+  class NoSuchBase < StandardError
+  end
+
+  class NoConnection < StandardError
+  end
+
+end

data/lib/airmodel/utils.rb

@@ -0,0 +1,100 @@
+module Airmodel
+  module Utils
+
+    def table_name
+      self.name.tableize.to_sym
+    end
+    #
+    # return an array of Airtable::Table objects,
+    # each backed by a base defined in DB YAML file
+    def tables(args={})
+      db = Airmodel.bases[table_name] || raise(NoSuchBase.new("Could not find base '#{table_name}' in config file"))
+      bases = normalized_base_config(db[:bases])
+      # return just one Airtable::Table if a particular shard was requested
+      if args[:shard]
+        [Airmodel.client.table(bases[args.delete(:shard)], db[:table_name])]
+      # otherwise return each one
+      else
+        bases.map{|key, val| Airmodel.client.table val, db[:table_name] }
+      end
+    end
+
+    def at(base_id, table_name)
+      Airmodel.client.table(base_id, table_name)
+    end
+
+    ## converts array of generic airtable records to the instances
+    # of the appropriate class
+    def classify(list=[])
+      list.map{|r| self.new(r.fields) }
+    end
+
+    # convert blank strings to nil, [""] to [], and "true" to a boolean
+    def airtable_formatted(hash)
+      h = hash.dup
+      h.each{|k,v|
+        if v == [""]
+          h[k] = []
+        elsif v == ""
+          h[k] = nil
+        elsif v == "true"
+          h[k] = true
+        elsif v == "false"
+          h[k] = false
+        end
+      }
+    end
+
+    # standardizes bases from config file, whether you've defined
+    # your bases as a single string, a hash, an array,
+    # or an array of hashes, returns hash of form { "base_label" => "base_id" }
+    def normalized_base_config(config)
+      if config.is_a? String
+        { "#{config}" => config }
+      elsif config.is_a? Array
+        parsed = config.map{|x|
+          if x.respond_to? :keys
+            [x.keys.first, x.values.first]
+          else
+            [x,x]
+          end
+        }
+        Hash[parsed]
+      else
+        config
+      end
+    end
+
+
+    # Returns a hash that removes any matches with the other hash
+    #
+    # {a: {b:"c"}} - {:a=>{:b=>"c"}}                   # => {}
+    # {a: [{c:"d"},{b:"c"}]} - {:a => [{c:"d"}, {b:"d"}]} # => {:a=>[{:b=>"c"}]}
+    #
+    def hash_diff!(first_hash, second_hash)
+      second_hash.each_pair do |k,v|
+        tv = first_hash[k]
+        if tv.is_a?(Hash) && v.is_a?(Hash) && v.present? && tv.present?
+          tv.diff!(v)
+        elsif v.is_a?(Array) && tv.is_a?(Array) && v.present? && tv.present?
+          v.each_with_index do |x, i| 
+            tv[i].diff!(x)
+          end
+          first_hash[k] = tv - [{}]
+        else
+          first_hash.delete(k) if first_hash.has_key?(k) && tv == v
+        end
+        first_hash.delete(k) if first_hash.has_key?(k) && first_hash[k].blank?
+      end
+      first_hash
+    end
+
+    def hash_diff(first_hash, second_hash)
+      hash_diff!(first_hash.dup, second_hash)
+    end
+
+    def -(first_hash, second_hash)
+      hash_diff(first_hash, second_hash)
+    end
+  end
+end

data/lib/airmodel/version.rb

@@ -0,0 +1,3 @@
+module Airmodel
+  VERSION = '0.0.1pre'
+end

data/spec/airmodel_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe Airmodel do
+
+  describe "bases" do
+    it 'should load Airtable base configuration from a YAML file' do
+      db = Airmodel.bases
+      expect(db).to eq YAML.load_file("#{Airmodel.root}/config/bases.yml")
+    end
+  end
+
+  describe "client" do
+    it 'should return a connected Airtable API client' do
+      client = Airmodel.client
+      expect(client.class).to eq Airtable::Client
+    end
+  end
+
+end

data/spec/models_spec.rb

@@ -0,0 +1,277 @@
+require 'spec_helper'
+
+class TestModel < Airmodel::Model
+end
+
+describe TestModel do
+
+  before(:each) do
+    config = Airmodel.bases[:test_models]
+    #stub INDEX requests
+    stub_airtable_response!(
+      Regexp.new("https://api.airtable.com/v0/#{config[:bases]}/#{config[:table_name]}"),
+      { "records" => [{"id": "recXYZ", fields: {"color":"red"} }, {"id":"recABC", fields: {"color": "blue"} }] }
+    )
+    #stub CREATE requests
+    stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table",
+      { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
+      :post
+    )
+  end
+
+  after(:each) do
+    FakeWeb.clean_registry
+  end
+
+  describe "Class Methods" do
+    describe "tables" do
+      it "should return Airtable::Table objects for each base in the config file" do
+        tables = TestModel.tables
+        tables.each do |t|
+          expect(t.class).to eq Airtable::Table
+          expect(t.app_token).not_to eq nil
+        end
+      end
+    end
+
+    describe "at" do
+      it "should connect to an arbitrary base and table" do
+        table = TestModel.at("hello", "world")
+        expect(table.class).to eq Airtable::Table
+      end
+    end
+
+    describe "records" do
+      it "should return a list of airtable records" do
+        records = TestModel.records
+        expect(records.first.id).to eq "recXYZ"
+      end
+    end
+
+    describe "classify" do
+      it "should return TestModels from Airtable::Records" do
+        array = [Airtable::Record.new]
+        results = TestModel.classify(array)
+        expect(results.first.class).to eq TestModel
+      end
+    end
+
+    describe "all" do
+      it "should return a list of airtable records" do
+        records = TestModel.all
+        expect(records.first.id).to eq "recXYZ"
+      end
+    end
+
+    describe "where" do
+      it "should return a list of airtable records that match filters" do
+        records = TestModel.where(color: "red")
+        expect(records.first.class).to eq TestModel
+        expect(records.first.color).to eq "red"
+      end
+    end
+
+    describe "find_by" do
+      it "should return one record that matches the supplied filters", skip_before: true do
+        stub_airtable_response!(
+          Regexp.new("https://api.airtable.com/v0/appXYZ/example_table"),
+          { "records" => [{"id":"recABC", fields: {"color": "blue"} }] }
+        )
+        record = TestModel.find_by(color: "blue")
+        expect(record.color).to eq "blue"
+      end
+      it "should call airtable-ruby's 'find' method when the filter is an id" do
+        stub_airtable_response! "https://api.airtable.com/v0/appXYZ/example_table/recABC", { "id":"recABC", fields: {"name": "example record"} }
+        record = TestModel.find_by(id: "recABC")
+        expect(record.name).to eq "example record"
+      end
+    end
+
+    describe "first" do
+      it "should return the first record" do
+        record = TestModel.first
+        expect(record.class).to eq TestModel
+      end
+    end
+
+    describe "create" do
+      it "should create a new record" do
+        record = TestModel.create(color: "red")
+        expect(record.id).to eq "12345"
+      end
+    end
+
+    describe "patch" do
+      it "should update a record" do
+        stub_airtable_response!(Regexp.new("/v0/appXYZ/example_table/12345"),
+          { "fields" => { "color" => "blue", "foo" => "bar" }, "id" => "12345" },
+          :patch
+        )
+        record = TestModel.create(color: "red")
+        record = TestModel.patch("12345", { color: "blue" })
+        expect(record.color).to eq "blue"
+      end
+    end
+
+  end
+
+  describe "Instance Methods" do
+
+    describe "save" do
+      record = TestModel.new(color: "red")
+      it "should create a new record" do
+        record.save
+        expect(record.id).to eq "12345"
+      end
+      it "should update an existing record" do
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+          { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
+          :get
+        )
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+          { "fields" => { "color" => "blue" }, "id" => "12345" },
+          :patch
+        )
+        record[:color] = "blue"
+        record.save
+        expect(record.color).to eq "blue"
+      end
+    end
+
+    describe "destroy" do
+      it "should delete a record" do
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+          { "deleted": true, "id" => "12345" },
+          :delete
+        )
+        response = TestModel.new(id: "12345").destroy
+        expect(response["deleted"]).to eq true
+      end
+    end
+
+    describe "update" do
+      it "should update the supplied attrs on an existing record" do
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+          { "fields" => { "color" => "green"}, "id" => "12345" },
+          :patch
+        )
+        record = TestModel.create(color: "red", id:"12345")
+        record.update(color: "green")
+        expect(record.color).to eq "green"
+      end
+    end
+
+    describe "cache_key" do
+      it "should return a unique key that can be used to id this record in memcached" do
+        record = TestModel.new(id: "recZXY")
+        expect(record.cache_key).to eq "test_models_recZXY"
+      end
+    end
+
+    describe "changed_fields" do
+      it "should return a hash of attrs changed since last save" do
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+          { fields: { 'color': 'red' }, "id" => "12345" },
+          :get
+        )
+        record = TestModel.create(color: 'red')
+        record[:color] = 'green'
+        expect(record.changed_fields).to have_key 'color'
+      end
+    end
+
+    describe "new_record?" do
+      it "should return true if the record hasn't been saved to airtable yet" do
+        record = TestModel.new(color: 'red')
+        expect(record.new_record?).to eq true
+      end
+    end
+
+    describe "formatted_fields" do
+      attrs = {
+        "empty_array": [''],
+        "empty_array_bis": [""],
+        "blank_string": "",
+        "truthy_string": "true",
+        "falsy_string": "false"
+      }
+      record = TestModel.new(attrs)
+      formatted_attrs = record.formatted_fields
+      it "should convert empty arrays [''] to []" do
+        expect(formatted_attrs["empty_array"]).to eq []
+        expect(formatted_attrs["empty_array_bis"]).to eq []
+      end
+      it "should convert blank strings to nil" do
+        expect(formatted_attrs["blank_string"]).to eq nil
+      end
+      it "should convert 'true' to a boolean" do
+        expect(formatted_attrs["truthy_string"]).to eq true
+      end
+      it "should convert 'false' to a boolean" do
+        expect(formatted_attrs["falsy_string"]).to eq false
+      end
+    end
+
+  end
+end
+
+class ShardedTestModel < Airmodel::Model
+end
+
+describe ShardedTestModel do
+  let(:config) { Airmodel.bases[:test_models_sharded] }
+
+  describe "class_methods" do
+
+    describe "tables" do
+      it "should return Airtable::Table objects for each base in the config file" do
+        tables = ShardedTestModel.tables
+        tables.each do |t|
+          expect(t.class).to eq Airtable::Table
+          expect(t.app_token.class).to eq String
+        end
+      end
+      it "should return just the one table matching args[:shard]" do
+        tables = ShardedTestModel.tables(shard: "east_coast")
+      end
+    end
+
+    describe "normalized_base_config" do
+      it "should return a hash from a string" do
+        sample_config = "appXYZ"
+        target = { "appXYZ" => "appXYZ" }
+        expect(TestModel.normalized_base_config(sample_config)).to eq target
+      end
+      it "should return a hash from an array of strings" do
+        sample_config = %w(appXYZ appABC)
+        target = { "appXYZ" => "appXYZ", "appABC" => "appABC" }
+        expect(TestModel.normalized_base_config(sample_config)).to eq target
+      end
+      it "should return a hash from an array of hashes" do
+        sample_config = [{"nyc": "appXYZ"}, {"sf": "appABC"}]
+        target = { "nyc": "appXYZ", "sf": "appABC" }
+        expect(TestModel.normalized_base_config(sample_config)).to eq target
+      end
+      it "should return itself from a hash" do
+        sample_config = {"nyc": "appXYZ", "sf": "appABC" }
+        target = { "nyc": "appXYZ", "sf": "appABC" }
+        expect(TestModel.normalized_base_config(sample_config)).to eq target
+      end
+    end
+
+  end
+end
+
+class BaselessTestModel < Airmodel::Model
+end
+
+describe BaselessTestModel do
+  describe "it should raise a NoSuchBaseError when no base is defined" do
+    begin
+      records = BaselessTestModel.records
+      false
+    rescue Airmodel::NoSuchBase
+      true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'airmodel'
+require 'fakeweb'
+require 'pry'
+
+def stub_airtable_response!(url, response, method=:get)
+  FakeWeb.register_uri(
+    method,
+    url,
+    body: response.to_json,
+    content_type: "application/json"
+  )
+end
+
+RSpec.configure do |config|
+  config.color = true
+end
+
+FakeWeb.allow_net_connect = false
+
+# enable Debug mode in Airtable
+module Airtable
+  # Base class for authorized resources sending network requests
+  class Resource
+    include HTTParty
+    base_uri 'https://api.airtable.com/v0/'
+    debug_output $stdout
+
+    attr_reader :api_key, :app_token, :worksheet_name
+
+    def initialize(api_key, app_token, worksheet_name)
+      @api_key = api_key
+      @app_token = app_token
+      @worksheet_name = worksheet_name
+      self.class.headers({'Authorization' => "Bearer #{@api_key}"})
+    end
+  end # AuthorizedResource
+end # Airtable

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: airmodel
+version: !ruby/object:Gem::Version
+  version: 0.0.1pre
+platform: ruby
+authors:
+- chrisfrankdotfm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: airtable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.8
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Airtable data in ActiveRecord-style syntax
+email:
+- chris.frank@thefutureproject.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- airmodel.gemspec
+- config/bases.yml
+- lib/airmodel.rb
+- lib/airmodel/model.rb
+- lib/airmodel/utils.rb
+- lib/airmodel/version.rb
+- spec/airmodel_spec.rb
+- spec/models_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/chrisfrank/airmodel
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Interact with your Airtable data using ActiveRecord-style models
+test_files: []