airmodel 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13bc3270f4a9eee17e8559404cdb9f0e9917f899
-  data.tar.gz: 8ddb417cbac7e452de3f7ca469007370c2a7f6e6
+  metadata.gz: 86835f77844aa599d172c8cb92e2aac8f13cbedf
+  data.tar.gz: d37a0a44a684f943f68ad7dc5e5ac077ac5752b9
 SHA512:
-  metadata.gz: 38013c380e9a5b226c1ab4fe3c80ce10f5901052e9962db2f480fe37c555e29d956accd00b832e83e5aa7fcc5545b2995833ee3a61c0dfa5e0d37775f9cf76ce
-  data.tar.gz: 3686e3416162fd2744cceb2f81ea0c0272ab4fa6d16009205e1f9d74e34308ef6011a7c6b72dbd558b1e4cd10a67a719b530665c20a1b18fee0765e377ac2a6a
+  metadata.gz: 9696fc07326864a461978321b419c09cc4755cef0235593b02f76af93a7ebc65f7259d567b2fb4dafb4f38d9e4514e7926258f559dec2c5e34cb022171c385a3
+  data.tar.gz: c91f7ead3cfb6ee25ae107804a3ea7529f4be08126c9f04f757e66b7e3dfb9fa6f449973902d26d1cde6c81a2f6fd55f7d144f2c5fe48f64605a2ae79ad869af

data/README.md

@@ -52,7 +52,9 @@ Now you can write code like
 
 		Song.all
 
-		Song.where("Artist Name": "The Beatles", "Composer": "Harrison")
+		Song.where("Artist Name" => "The Beatles", "Composer" => "Harrison")
+
+		Song.search(:q => "Let it Be", fields: ["Name", "Album"])
 
 		Song.first
 
@@ -60,29 +62,35 @@ Now you can write code like
 
 		Song.find("recXYZ")
 
-		Song.find(["recXYZ", "recABC", "recJKL"])
+		Song.find_by("Composer" => "Harrison")
 
 
-Most queries are chainable, e.g.
+Queries are chainable, e.g.
 
-		Song.where("rating" => 5).where('artist' => "Fiona Apple").order("rating", "DESC").limit(5)
+		Song.where("rating" => 5).where('Artist' => "Fiona Apple").order("rating", "DESC").limit(5)
 
-There's also a special `Model.by_formula` query, which overrides any filters
-supplied in your `Model.where()` statements, and replaces them with a raw
+There's also a `Model.by_formula` query, which lets you pass explicit 
 [Airtable
-Formula](https://support.airtable.com/hc/en-us/articles/203255215-Formula-field-reference)
+Formulas](https://support.airtable.com/hc/en-us/articles/203255215-Formula-field-reference)
 
-You can still chain `.limit` and `.order` with a `.by_forumla` query.
+You can chain `.limit` and `.order` with a `.by_forumla` query.
 
 		Song.by_formula("NOT({Rating} < 3)").order("rating", "DESC").limit(5)
 
-See lib/airmodel/model.rb for all available methods.
+See `lib/airmodel/model.rb` for all model methods, and
+`lib/airmodel/query.rb` for all Query methods.
 
 
 Contributions
 ----------------
 
-Add a passing test to spec/model_spec.rb, then send a pull
-request. Thanks!
+I'm currently testing against a live Airtable base, because stubbing API
+calls has occasionally yielded false positives in my specs. To run the tests,
+create an Airtable account, set `AIRTABLE_API_KEY=[your API key]` in your `.env` file, and
+then visit [this link](https://airtable.com/invite/l?inviteId=invj96HyFOB6GF8Vq&inviteToken=2e98eff03a646162344bb997a06645e3)
+to request access to the base.
+
+Once that's all set, write a passing test for your feature and send a pull request.
 
+Thanks!
 

data/airmodel.gemspec

@@ -20,8 +20,10 @@ Gem::Specification.new do |spec|
   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_development_dependency 'vcr', '~> 3.0'
+  spec.add_development_dependency 'dotenv', '~> 2.1'
+  spec.add_development_dependency 'webmock', '~> 2.3'
 
   spec.add_dependency 'airtable', '~> 0.0.9'
-  spec.add_dependency 'activesupport', '~> 5.0'
+  spec.add_dependency 'activesupport', '~> 4.0'
 end

data/config/bases.yml

@@ -1,6 +1,6 @@
 :albums:
-  :table_name: "albums"
-  :base_id: appXYZ
+  :table_name: Albums
+  :base_id: appTE8VIb595FI4c6
 :songs:
-  :table_name: "songs"
-  :base_id: appXYZ
+  :table_name: Songs
+  :base_id: appTE8VIb595FI4c6

data/lib/airmodel.rb

@@ -14,7 +14,7 @@ module Airmodel
     File.expand_path '../..', __FILE__
   end
 
-  def self.client(api_key=ENV["AIRTABLE_API_KEY"])
+  def self.client(api_key=ENV.fetch("AIRTABLE_API_KEY") )
     @@api_client ||= Airtable::Client.new(api_key)
     @@api_client
   end

data/lib/airmodel/associable.rb

@@ -15,10 +15,15 @@ module Airmodel
                      base_id: self.send(args[:base_key]),
                      table_name: args[:table_name] || association_name.to_s.tableize
                    }
+                   # maybe the base is defined in the config file
+                 elsif c = Airmodel.bases[args[:class_name].tableize.to_sym]
+                   c
+                # maybe the base is just a table in the same base as the parent
                  else
-                   # the airtable base info is defined in the
-                   # YML config file, with the rest of the data
-                   Airmodel.bases[args[:class_name].tableize.to_sym] || raise(NoSuchBase.new("Couldn't find base '#{association_name}' in config file.\nPlease pass :base_key => foo with your has_many call,\nor add '#{association_name}' to your config file."))
+                   {
+                     base_id: self.class.base_config[:base_id],
+                     table_name: args[:table_name] || association_name.to_s.tableize
+                   }
                  end
         finder_name = "@#{association_name}_finder"
         if f = instance_variable_get(finder_name)
@@ -28,10 +33,19 @@ module Airmodel
             @base_id = config[:base_id]
             @table_name = config[:table_name]
           end
-          instance_variable_set(finder_name, finder)
+          constraints = if args[:constraints].respond_to?(:call)
+                          args[:constraints].call(self)
+                        else
+                          {}
+                        end
+          instance_variable_set(finder_name, finder.where(constraints))
         end
       end
     end
 
+    def default_has_many_contraints
+      true
+    end
+
   end
 end

data/lib/airmodel/model.rb

@@ -15,10 +15,16 @@ module Airmodel
       Query.new(self).by_formula(args)
     end
 
+    def self.search(args)
+      Query.new(self).search(args)
+    end
+
+    # Model.order("Name DESC")
     def self.order(args)
-      Query.new(self).order(args)
+      Query.new(self).order(*args)
     end
 
+    # Model.limit(10)
     def self.limit(args)
       Query.new(self).limit(args)
     end
@@ -45,18 +51,7 @@ module Airmodel
 
     # find a record by specified attributes, return it
     def self.find_by(filters)
-      if filters[:id]
-        results = self.classify table.find(filters[:id])
-      else
-        formula = "AND(" + filters.map{|k,v| "{#{k}}='#{v}'" }.join(',') + ")"
-        results = self.classify(
-          table.records(
-            filterByFormula: formula,
-            limit: 1
-          )
-        )
-      end
-      results.count == 0 ? nil : results.first
+      Query.new(self).find_by(filters)
     end
 
     # default to whatever order Airtable returns

data/lib/airmodel/query.rb

@@ -1,5 +1,6 @@
 module Airmodel
   class Query
+    include Enumerable
 
     def initialize(querying_class)
       @querying_class = querying_class
@@ -8,7 +9,9 @@ module Airmodel
     def params
       @params ||= {
         where_clauses: {},
-        order: @querying_class.default_sort
+        formulas: [],
+        order: @querying_class.default_sort,
+        offset: nil
       }
     end
 
@@ -18,45 +21,76 @@ module Airmodel
     end
 
     def by_formula(formula)
-      params[:where_clauses] = {}
-      params[:formula] = formula
+      params[:formulas].push formula
+      self
+    end
+
+    def search(args={})
+      if args && args[:q] && args[:fields]
+        searchfields = if args[:fields].is_a?(String)
+                        args[:fields].split(",").map{|f| f.strip }
+                       else
+                         args[:fields]
+                       end
+        query = if args[:q].respond_to?(:downcase)
+                  args[:q].downcase
+                else
+                  args[:q]
+                end
+        f = "OR(" + searchfields.map{|field|
+          # convert strings to case-insensitive searches
+          "FIND('#{query}', LOWER({#{field}}))"
+        }.join(',') + ")"
+        params[:formulas].push f
+      end
       self
     end
 
     def limit(lim)
-      params[:limit] = lim
+      params[:limit] = lim ? lim.to_i : nil
       self
     end
 
-    def order(column, direction)
-      params[:order] = [column, direction.downcase.to_sym]
+    def order(order_string)
+      if order_string
+        ordr = order_string.split(" ")
+        column = ordr.first
+        direction = ordr.length > 1 ? ordr.last.downcase : "asc"
+        params[:order] = [column, direction]
+      end
       self
     end
 
+
+    def offset(airtable_offset_key)
+      params[:offset] = airtable_offset_key
+      self
+    end
+
+    # return saved airtable offset for this query
+    def get_offset
+      @offset
+    end
+
     # add kicker methods
     def to_a
       puts "RUNNING EXPENSIVE API QUERY TO AIRTABLE (#{@querying_class.name})"
-      # filter by explicit formula, or by joining all where_clasues together
-      formula = params[:formula] || "AND(" + params[:where_clauses].map{|k,v| "{#{k}}='#{v}'" }.join(',') + ")"
-      @querying_class.classify @querying_class.table.all(
+      # merge explicit formulas and abstracted where-clauses into one Airtable Formula
+      formula = "AND(" + params[:where_clauses].map{|k,v| "{#{k}}='#{v}'" }.join(',') + params[:formulas].join(',') + ")"
+      records = @querying_class.table.records(
         sort: params[:order],
         filterByFormula: formula,
-        limit: params[:limit]
+        limit: params[:limit],
+        offset: params[:offset]
       )
+      @offset = records.offset
+      @querying_class.classify records
     end
 
     def all
       to_a
     end
 
-    def first
-      to_a.first
-    end
-
-    def last
-      to_a.last
-    end
-
     def each(&block)
       to_a.each(&block)
     end
@@ -69,6 +103,16 @@ module Airmodel
       to_a.inspect
     end
 
+    def last
+      to_a.last
+    end
+
+    def find_by(filters)
+      params[:limit] = 1
+      params[:where_clauses] = filters
+      first
+    end
+
   end
 end
 

data/lib/airmodel/version.rb

@@ -1,3 +1,3 @@
 module Airmodel
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/spec/associable_spec.rb

@@ -3,45 +3,37 @@ require 'spec_helper'
 class Song < Airmodel::Model
 end
 
+class Album < Airmodel::Model
+end
+
 class ParentModel < Airmodel::Model
   has_many :songs
 
   def dynamically_assigned_child_base_id
-    'appABCDEF'
+    "appTE8VIb595FI4c6"
   end
+
 end
 
 describe ParentModel do
 
-  before(:each) do
-    config = Airmodel.bases[:albums]
-    #stub INDEX requests
-    stub_airtable_response!(
-      Regexp.new("https://api.airtable.com/v0/#{config[:base_id]}/#{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/albums",
-      { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
-      :post
-    )
-  end
-
-  after(:each) do
-    FakeWeb.clean_registry
-  end
-
-
   describe 'has_many' do
     it 'should return a list of songs' do
       songs = ParentModel.new.songs
-      expect(songs.table_name).to eq 'songs'
+      expect(songs.first.is_a? Song).to be true
+    end
+
+    it "Should look in the parent model's base when not passed a base_key" do
+      Song.has_many :albums
+      albums = Song.first.albums.all
+      expect(albums.first.name).to eq "Blood on the Tracks"
     end
 
     it 'should raise NoSuchBase when passed a weird association not backed by bases.yml' do
       begin
         ParentModel.has_many :unusual_children
-        false
+        ParentModel.new.unusual_children
+        expect(true).to eq false
       rescue Airmodel::NoSuchBase
         true
       end
@@ -52,13 +44,9 @@ describe ParentModel do
     end
 
     it 'should work with a base_key instead of a yml file' do
-      stub_airtable_response!(
-        Regexp.new("https://api.airtable.com/v0/appABCDEF/tunes"),
-        { "records" => [{"id": "recXYZ", fields: {"color":"red"} }, {"id":"recABC", fields: {"color": "blue"} }] }
-      )
-      ParentModel.has_many :tunes, base_key: 'dynamically_assigned_child_base_id', class_name: 'Song'
+      ParentModel.has_many :tunes, base_key: 'dynamically_assigned_child_base_id', class_name: 'Song', table_name: "Songs"
       tunes = ParentModel.new.tunes
-      expect(tunes.first.table.worksheet_name).to eq 'tunes'
+      expect(tunes.first.table.worksheet_name).to eq "Songs"
     end
 
     it 'should let me define the important args however I like'

data/spec/model_spec.rb

@@ -5,24 +5,6 @@ end
 
 describe Album do
 
-  before(:each) do
-    config = Airmodel.bases[:albums]
-    #stub INDEX requests
-    stub_airtable_response!(
-      Regexp.new("https://api.airtable.com/v0/#{config[:base_id]}/#{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/albums",
-      { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
-      :post
-    )
-  end
-
-  after(:each) do
-    FakeWeb.clean_registry
-  end
-
   describe "Class Methods" do
     describe "table" do
       it "should return an Airtable::Table object" do
@@ -48,53 +30,47 @@ describe Album do
     end
 
     describe "all" do
+      use_vcr_cassette
       it "should return a list of airtable records" do
         records = Album.all
-        expect(records.first.id).to eq "recXYZ"
+        expect(records.first.id).to eq "rec0bTuIoUQVPMsmi"
       end
     end
 
     describe "where" do
+      use_vcr_cassette
       it "should return a list of airtable records that match filters" do
-        records = Album.where(color: "red")
+        records = Album.where(name: "Blood on the Tracks")
         expect(records.first.class).to eq Album
-        expect(records.first.color).to eq "red"
+        expect(records.first.name).to eq "Blood on the Tracks"
       end
     end
 
     describe "find" do
+      use_vcr_cassette
       it "should call airtable-ruby's 'find' method when passed just one record ID" do
-        stub_airtable_response! "https://api.airtable.com/v0/appXYZ/albums/recABC", { "id":"recABC", fields: {"name": "example record"} }
-        record = Album.find("recABC")
-        expect(record.name).to eq "example record"
+        record = Album.find("rec52DfV4E2I2kzrS")
+        expect(record.name).to eq "Voodoo"
       end
       it "should return an ordered list of records when passed an array of record IDs" do
-        records = Album.find(["recABC", "recXYZ"])
+        records = Album.find(["rec52DfV4E2I2kzrS", "rec0bTuIoUQVPMsmi"])
         expect(records.class).to eq Array
-        expect(records.first.id).to eq "recABC"
+        expect(records.first.id).to eq "rec52DfV4E2I2kzrS"
         expect(records.first.class).to eq Album
       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/albums"),
-          { "records" => [{"id":"recABC", fields: {"color": "blue"} }] }
-        )
-        record = Album.find_by(color: "blue")
-        expect(record.color).to eq "blue"
-        expect(record.class).to eq Album
-      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/albums/recABC", { "id":"recABC", fields: {"name": "example record"} }
-        record = Album.find_by(id: "recABC")
-        expect(record.name).to eq "example record"
+      use_vcr_cassette
+      it "should return one record that matches the supplied filters" do
+        record = Album.find_by(name: "Voodoo")
+        expect(record.name).to eq "Voodoo"
         expect(record.class).to eq Album
       end
     end
 
     describe "first" do
+      use_vcr_cassette
       it "should return the first record" do
         record = Album.first
         expect(record.class).to eq Album
@@ -102,21 +78,22 @@ describe Album do
     end
 
     describe "create" do
+      use_vcr_cassette
       it "should create a new record" do
-        record = Album.create(color: "red")
-        expect(record.id).to eq "12345"
+        record = Album.create("Name" => "Abbey Road")
+        expect(record.id).not_to eq nil
+        record.destroy
       end
     end
 
     describe "patch" do
+      use_vcr_cassette
       it "should update a record" do
-        stub_airtable_response!(Regexp.new("/v0/appXYZ/albums/12345"),
-          { "fields" => { "color" => "blue", "foo" => "bar" }, "id" => "12345" },
-          :patch
-        )
-        record = Album.create(color: "red")
-        record = Album.patch("12345", { color: "blue" })
-        expect(record.color).to eq "blue"
+        record = Album.create("Name" => "Let It Be")
+        notes = "It wasn't really their last one"
+        record = Album.patch(record.id, { "Notes" => notes })
+        expect(record.notes).to eq notes
+        record.destroy
       end
     end
 
@@ -125,71 +102,56 @@ describe Album do
   describe "Instance Methods" do
 
     describe "save" do
-      record = Album.new(color: "red")
       it "should create a new record" do
+        record = Album.new("Name" => "His California Record")
         record.save
-        expect(record.id).to eq "12345"
+        expect(record.id).not_to be nil
+        record.destroy
       end
       it "should update an existing record" do
-        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
-          { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
-          :get
-        )
-        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
-          { "fields" => { "color" => "blue" }, "id" => "12345" },
-          :patch
-        )
-        record[:color] = "blue"
+        record = Album.create("Name" => "His California Record")
+        record["Artist"] = "Bobby Bland"
         record.save
-        expect(record.color).to eq "blue"
+        expect(record.artist).to eq "Bobby Bland"
+        record.destroy
       end
     end
 
     describe "destroy" do
       it "should delete a record" do
-        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
-          { "deleted": true, "id" => "12345" },
-          :delete
-        )
-        response = Album.new(id: "12345").destroy
+        response = Album.create("Name" => "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/albums/12345",
-          { "fields" => { "color" => "green"}, "id" => "12345" },
-          :patch
-        )
-        record = Album.create(color: "red", id:"12345")
-        record.update(color: "green")
-        expect(record.color).to eq "green"
+        record = Album.create("Name" => "Blue")
+        record.update("Name" => "Green")
+        expect(record.name).to eq "Green"
+        record.destroy
       end
     end
 
     describe "cache_key" do
       it "should return a unique key that can be used to id this record in memcached" do
-        record = Album.new(id: "recZXY")
-        expect(record.cache_key).to eq "albums_recZXY"
+        record = Album.first
+        expect(record.cache_key).to eq "albums_#{record.id}"
       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/albums/12345",
-          { fields: { 'color': 'red' }, "id" => "12345" },
-          :get
-        )
-        record = Album.create(color: 'red')
-        record[:color] = 'green'
-        expect(record.changed_fields).to have_key 'color'
+        record = Album.create("Name" => "Pinkerton")
+        record["Name"] = "Green"
+        expect(record.changed_fields).to have_key "Name"
+        record.destroy
       end
     end
 
     describe "new_record?" do
       it "should return true if the record hasn't been saved to airtable yet" do
-        record = Album.new(color: 'red')
+        record = Album.new("Name" => "Jim!")
         expect(record.new_record?).to eq true
       end
     end

data/spec/query_spec.rb

@@ -5,41 +5,87 @@ end
 
 describe Album do
 
-  before(:each) do
-    config = Airmodel.bases[:albums]
-    #stub INDEX requests
-    stub_airtable_response!(
-      Regexp.new("https://api.airtable.com/v0/#{config[:base_id]}/#{config[:table_name]}"),
-      { "records" => [{"id": "recXYZ", fields: {"color":"red"} }, {"id":"recABC", fields: {"color": "blue"} }] }
-    )
-  end
-
-  after(:each) do
-    FakeWeb.clean_registry
-  end
-
-
   describe "where" do
     it "allows chaining" do
       q = Album.where(
         "name" => "Tidal",
-        "artist" => "Fiona Apple",
-        "great" => true
-      ).limit(10)
+        "artist" => "Fiona Apple"
+      ).limit(10).order("Name DESC")
       expect(q.class).to eq Airmodel::Query
       # it should execute the query on
       # query.all, and return an array
       expect(q.all.class).to be Array
+      expect(q.count).to eq 1
     end
 
-    it "can replace where_clauses with a raw airtable formula" do
-      formula = "NOT({Rating} < 4"
-      q = Album.where("great" => true).by_formula(formula)
-      expect(q.params[:where_clauses]).to be {}
-      expect(q.params[:formula]).to be formula
+    it "can use a raw airtable formula" do
+      formula = "NOT({Rating} > 3)"
+      q = Album.by_formula(formula)
+      expect(q.params[:formulas].to_s).to eq [formula].to_s
       expect(q.all.class).to be Array
+      expect(q.count).to eq 1
     end
   end
 
-end
+  describe "limit" do
+    it "limits the results to the specified number" do
+      q = Album.limit(2)
+      expect(q.count).to eq 2
+    end
+
+    it "accepts a string instead of an integer" do
+      q = Album.limit("1")
+      expect(q.count).to eq 1
+    end
+
+    it "accepts nil as an all-pass filter" do
+      q = Album.limit(nil)
+      expect(q.count).to eq Album.all.count
+    end
+  end
+
+  describe "search" do
+    it "searches in args[:fields] for args[:value]" do
+      q = Album.search(q: "Fiona", fields: ["Artist"])
+      expect(q.count).to eq 1
+      expect(q.first.artist).to eq "Fiona Apple"
+    end
 
+    it "can search across multiple fields" do
+      q = Album.search(q: "Sinatra", fields: ["Artist", "Name"])
+      expect(q.count).to eq 2
+      expect(q.first.artist).to eq "Frank Sinatra"
+      expect(q.last.artist).to eq "Dylan"
+    end
+
+    it "can accept field names as a string" do
+      q = Album.search(q: "Sinatra", fields: "Artist, Name")
+      expect(q.count).to eq 2
+      expect(q.first.artist).to eq "Frank Sinatra"
+      expect(q.last.artist).to eq "Dylan"
+    end
+
+    it "is not case-sensitive w/r/t queries" do
+      q = Album.search(q: "dylan", fields: "Artist")
+      expect(q.count).to eq 2
+    end
+
+    it "accepts nil as an all-pass filter" do
+      q = Album.search(nil)
+      expect(q.count).to eq Album.all.count
+    end
+
+  end
+
+  describe "order" do
+    it "can order when passed an array" do
+      q = Album.order("Name ASC")
+      expect(q.first.name).to eq "A Swingin' Affair"
+      q = Album.order("Name")
+      expect(q.first.name).to eq "A Swingin' Affair"
+      q = Album.order("Name DESC")
+      expect(q.first.name).to eq "Voodoo"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,21 +1,20 @@
-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
+require "airmodel"
+require "pry"
+require "vcr"
+require "dotenv"
+Dotenv.load
 
 RSpec.configure do |config|
   config.color = true
+  config.extend VCR::RSpec::Macros
+  config.order = :random
 end
 
-FakeWeb.allow_net_connect = false
+VCR.configure do |config| config.allow_http_connections_when_no_cassette = true
+  config.cassette_library_dir = "#{Airmodel.root}/spec/fixtures/vcr_cassettes"
+  config.default_cassette_options = { :record => :new_episodes }
+  config.filter_sensitive_data("<AIRTABLE_API_KEY>") { ENV.fetch('AIRTABLE_API_KEY') }
+end
 
 # enable Debug mode in Airtable
 module Airtable

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airmodel
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - chrisfrankdotfm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2016-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,19 +67,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: fakeweb
+  name: vcr
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: airtable
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +128,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '4.0'
 description: Airtable data in ActiveRecord-style syntax
 email:
 - chris.frank@thefutureproject.org
@@ -152,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Interact with your Airtable data using ActiveRecord-style models