airmodel 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0993017b73e85cdf5feea7202fe15bc08b7337db
-  data.tar.gz: 96efc042d20d434f44e31485f2f585a18aa26522
+  metadata.gz: 13bc3270f4a9eee17e8559404cdb9f0e9917f899
+  data.tar.gz: 8ddb417cbac7e452de3f7ca469007370c2a7f6e6
 SHA512:
-  metadata.gz: b6198d0499f0b32b0d7d6df2dd16ea5405cdf8fd9125ac87118416082587080e1c775319aef2359825f8c458455483fc88883dc5b5c4c2fc6b84866c15cb078e
-  data.tar.gz: 574e06e6344caee7da1ed5e904bbe6fabaf58f313e8714fe5305de108a1c7dfb109c6b6cfd33b411f2ad1200a3ef86ac6ebae91b3e13a112a1a10741181cb454
+  metadata.gz: 38013c380e9a5b226c1ab4fe3c80ce10f5901052e9962db2f480fe37c555e29d956accd00b832e83e5aa7fcc5545b2995833ee3a61c0dfa5e0d37775f9cf76ce
+  data.tar.gz: 3686e3416162fd2744cceb2f81ea0c0272ab4fa6d16009205e1f9d74e34308ef6011a7c6b72dbd558b1e4cd10a67a719b530665c20a1b18fee0765e377ac2a6a

data/README.md

@@ -30,20 +30,11 @@ before your app starts...
 
 		:songs:
 			:table_name: Songs
-			:bases: appXYZ123ABC
+			:base_id: appXYZ123ABC
 		:albums:
 			:table_name: Albums
-			:bases: appZZTOPETC
+			:base_id: 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
 ----------------
@@ -61,27 +52,37 @@ Now you can write code like
 
 		Song.all
 
-		Song.some
+		Song.where("Artist Name": "The Beatles", "Composer": "Harrison")
 
 		Song.first
 
 		Song.new("Name": "Best Song Ever").save
 
-		Song.where("Artist Name": "The Beatles", "Composer": "Harrison")
-
 		Song.find("recXYZ")
 
 		Song.find(["recXYZ", "recABC", "recJKL"])
 
+
+Most queries are chainable, e.g.
+
+		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
+[Airtable
+Formula](https://support.airtable.com/hc/en-us/articles/203255215-Formula-field-reference)
+
+You can still 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.
 
 
 Contributions
 ----------------
 
-Add a test to spec/models_spec.rb, make sure it passes, then send a pull
+Add a passing test to spec/model_spec.rb, then send a pull
 request. Thanks!
 
 
-
-

data/config/bases.yml

@@ -1,8 +1,6 @@
-:test_models:
-  :table_name: "example_table"
-  :bases: appXYZ
-:sharded_test_models:
-  :table_name: "example_table"
-  :bases:
-    "nyc": appLGA
-    "sf": appSFO
+:albums:
+  :table_name: "albums"
+  :base_id: appXYZ
+:songs:
+  :table_name: "songs"
+  :base_id: appXYZ

data/lib/airmodel.rb

@@ -2,7 +2,9 @@ require 'active_support/all'
 require 'airtable'
 
 require "airmodel/version"
+require "airmodel/query"
 require "airmodel/utils"
+require "airmodel/associable"
 require "airmodel/model"
 
 # builds ActiveRecord-style models on top of Airtable

data/lib/airmodel/associable.rb

@@ -0,0 +1,37 @@
+module Airmodel
+  module Associable
+
+    # defines a clone of the child class on this model
+    # required args: association_name
+    def has_many(association_name, args={})
+      args[:class_name] ||= association_name.to_s.singularize.capitalize
+      define_method association_name do
+        config = if args[:base_key]
+                   # the airtable base_id is dynamically configured
+                   # as a column on the parent model,
+                   # and the table_name is either passed as
+                   # an argument or inferrred from the child model name
+                   {
+                     base_id: self.send(args[:base_key]),
+                     table_name: args[:table_name] || association_name.to_s.tableize
+                   }
+                 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."))
+                 end
+        finder_name = "@#{association_name}_finder"
+        if f = instance_variable_get(finder_name)
+          f
+        else
+          finder = Class.new(Object.const_get args[:class_name]) do
+            @base_id = config[:base_id]
+            @table_name = config[:table_name]
+          end
+          instance_variable_set(finder_name, finder)
+        end
+      end
+    end
+
+  end
+end

data/lib/airmodel/model.rb

@@ -1,32 +1,26 @@
 module Airmodel
   class Model < Airtable::Record
     extend Utils
+    extend Associable
 
-    # returns all records in a table, making as many calls as necessary
-    # to work around Airtable's 100-record per page design. This can be VERY
-    # slow, and should not be used in production unless you cache it agressively.
-    # Where possible, use Model.some instead.
-    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
+    def self.all
+      Query.new(self).all
     end
 
-    # returns up to 100 records from Airtable
-    def self.some(args={sort: default_sort})
-      puts "RUNNING EXPENSIVE API QUERY TO AIRTABLE (#{self.name})"
-      self.classify tables(args).map{|tbl| tbl.records(args) }.flatten
+    def self.where(args)
+      Query.new(self).where(args)
     end
 
-    # find up to 100 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(',') + ")"
-      some(
-        shard: shard,
-        sort: order,
-        filterByFormula: formula,
-      )
+    def self.by_formula(args)
+      Query.new(self).by_formula(args)
+    end
+
+    def self.order(args)
+      Query.new(self).order(args)
+    end
+
+    def self.limit(args)
+      Query.new(self).limit(args)
     end
 
     # find a record by ID.
@@ -35,29 +29,31 @@ module Airmodel
     # THEN you can pass self.find([an,array,of,ids]) and it will return
     # each record in that order. This is mostly only useful for looking up
     # records linked to a particular record.
-    def self.find(id, shard=nil)
+    def self.find(id)
       if id.is_a? String
-        results = self.classify tables(shard: shard).map{|tbl| tbl.find(id) }
+        results = self.classify table.find(id)
         results.count == 0 ? nil : results.first
       else
         formula = "OR(" + id.map{|x| "id='#{x}'" }.join(',') + ")"
-        some(shard: shard, filterByFormula: formula).sort_by do |x|
-          id.index(x.id)
-        end
+        self.classify(
+          table.records(filterByFormula: formula).sort_by do |x|
+            id.index(x.id)
+          end
+        )
       end
     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]) }
+        results = self.classify table.find(filters[:id])
       else
         formula = "AND(" + filters.map{|k,v| "{#{k}}='#{v}'" }.join(',') + ")"
-        results = some(
-          shard: shard,
-          filterByFormula: formula,
-          limit: 1
+        results = self.classify(
+          table.records(
+            filterByFormula: formula,
+            limit: 1
+          )
         )
       end
       results.count == 0 ? nil : results.first
@@ -71,48 +67,44 @@ module Airmodel
 
     # return the first record
     def self.first
-      results = some(
-        limit: 1
-      )
-      results.count == 0 ? nil : results.first
+      Query.new(self).first
     end
 
     # create a new record and save it to Airtable
     def self.create(*models)
       results = models.map{|r|
         record = self.new(r)
-        tables.map{|tbl| tbl.create(record) }.first
+        table.create(record)
       }
       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
+    def self.patch(id, fields)
+      r = table.update_record_fields(id, airtable_formatted(fields))
       self.new(r.fields)
     end
 
     # INSTANCE METHODS
 
+    # return self.class.table. defined as an instance
+    # method to allow individual models to override it and
+    # connect to a different base in strange circumstances.
+    def table
+      self.class.table
+    end
+
     def formatted_fields
       self.class.airtable_formatted(self.fields)
     end
 
-    def save(shard=self.shard_identifier)
+    def save
       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 }
+          self.table.create(self)
         else
-          results = self.class.tables(shard: shard).map{|tbl|
-            tbl.update_record_fields(id, self.changed_fields)
-          }
-          results.find{|x| !!x }
+          result = self.table.update_record_fields(id, self.changed_fields)
+          result
         end
       else
         false
@@ -121,18 +113,18 @@ module Airmodel
 
     def changed_fields
       current = fields
-      old = self.class.find_by(id: id, shard: shard_identifier).fields
+      old = self.class.find_by(id: id).fields
       self.class.hash_diff(current, old)
     end
 
     def destroy
-      self.class.tables(shard: shard_identifier).map{|tbl| tbl.destroy(id) }.first
+      self.table.destroy(id)
     end
 
     def update(fields)
-      res = self.class.tables(shard: shard_identifier).map{|tbl| tbl.update_record_fields(id, fields) }.first
+      res = self.table.update_record_fields(id, fields)
       res.fields.each{|field, value| self[field] = value }
-      true
+      self
     end
 
     def new_record?
@@ -153,13 +145,6 @@ module Airmodel
       {}
     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

data/lib/airmodel/query.rb

@@ -0,0 +1,74 @@
+module Airmodel
+  class Query
+
+    def initialize(querying_class)
+      @querying_class = querying_class
+    end
+
+    def params
+      @params ||= {
+        where_clauses: {},
+        order: @querying_class.default_sort
+      }
+    end
+
+    def where(args)
+      params[:where_clauses].merge!(args)
+      self
+    end
+
+    def by_formula(formula)
+      params[:where_clauses] = {}
+      params[:formula] = formula
+      self
+    end
+
+    def limit(lim)
+      params[:limit] = lim
+      self
+    end
+
+    def order(column, direction)
+      params[:order] = [column, direction.downcase.to_sym]
+      self
+    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(
+        sort: params[:order],
+        filterByFormula: formula,
+        limit: params[:limit]
+      )
+    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
+
+    def map(&block)
+      to_a.map(&block)
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+  end
+end
+

data/lib/airmodel/utils.rb

@@ -2,22 +2,22 @@ module Airmodel
   module Utils
 
     def table_name
-      self.name.tableize.to_sym
+      @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_list = normalized_base_config(db[:bases])
-      # return just one Airtable::Table if a particular shard was requested
-      if args[:shard]
-        [Airmodel.client.table(bases_list[args.delete(:shard)], db[:table_name])]
-      # otherwise return each one
+
+    def base_config
+      if @base_id
+        { :base_id => @base_id, :table_name => table_name }
       else
-        bases_list.map{|key, val| Airmodel.client.table val, db[:table_name] }
+        Airmodel.bases[table_name] || raise(NoSuchBase.new("Could not find base '#{table_name}' in config file"))
       end
     end
+    #
+    # return an Airtable::Table object,
+    # backed by a base defined in DB YAML file
+    def table
+      Airmodel.client.table base_config[:base_id], base_config[:table_name]
+    end
 
     def at(base_id, table_name)
       Airmodel.client.table(base_id, table_name)
@@ -25,8 +25,14 @@ module Airmodel
 
     ## converts array of generic airtable records to the instances
     # of the appropriate class
-    def classify(list=[])
-      list.map{|r| self.new(r.fields) }
+    def classify(obj=[])
+      if obj.is_a? Airtable::Record
+        [self.new(obj.fields)]
+      elsif obj.respond_to? :map
+        obj.map{|r| self.new(r.fields) }
+      else
+        raise AlienObject.new("Object is neither an array nor an Airtable::Model")
+      end
     end
 
     # convert blank strings to nil, [""] to [], and "true" to a boolean
@@ -45,27 +51,6 @@ module Airmodel
       }
     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"}}                   # => {}
@@ -96,5 +81,9 @@ module Airmodel
     def -(first_hash, second_hash)
       hash_diff(first_hash, second_hash)
     end
+
+    class AlienObject < StandardError
+    end
+
   end
 end

data/lib/airmodel/version.rb

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

data/spec/associable_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class Song < Airmodel::Model
+end
+
+class ParentModel < Airmodel::Model
+  has_many :songs
+
+  def dynamically_assigned_child_base_id
+    'appABCDEF'
+  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'
+    end
+
+    it 'should raise NoSuchBase when passed a weird association not backed by bases.yml' do
+      begin
+        ParentModel.has_many :unusual_children
+        false
+      rescue Airmodel::NoSuchBase
+        true
+      end
+    end
+
+    it 'should work when passed a weird association that *is* backed by bases.yml' do
+      ParentModel.has_many :tracks, class_name: 'Song'
+    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'
+      tunes = ParentModel.new.tunes
+      expect(tunes.first.table.worksheet_name).to eq 'tunes'
+    end
+
+    it 'should let me define the important args however I like'
+
+  end
+
+end
+
+

data/spec/{models_spec.rb → model_spec.rb}

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-class TestModel < Airmodel::Model
+class Album < Airmodel::Model
 end
 
-describe TestModel do
+describe Album do
 
   before(:each) do
-    config = Airmodel.bases[:test_models]
+    config = Airmodel.bases[:albums]
     #stub INDEX requests
     stub_airtable_response!(
-      Regexp.new("https://api.airtable.com/v0/#{config[:bases]}/#{config[:table_name]}"),
+      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/example_table",
+    stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums",
       { "fields" => { "color" => "red", "foo" => "bar" }, "id" => "12345" },
       :post
     )
@@ -24,104 +24,98 @@ describe TestModel do
   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
+    describe "table" do
+      it "should return an Airtable::Table object" do
+        table = Album.table
+        expect(table.class).to eq Airtable::Table
+        expect(table.app_token).not_to eq nil
       end
     end
 
     describe "at" do
       it "should connect to an arbitrary base and table" do
-        table = TestModel.at("hello", "world")
+        table = Album.at("hello", "world")
         expect(table.class).to eq Airtable::Table
       end
     end
 
-    describe "some" do
-      it "should return a list of airtable records" do
-        records = TestModel.some
-        expect(records.first.id).to eq "recXYZ"
-      end
-    end
-
     describe "classify" do
-      it "should return TestModels from Airtable::Records" do
+      it "should return albums from Airtable::Records" do
         array = [Airtable::Record.new]
-        results = TestModel.classify(array)
-        expect(results.first.class).to eq TestModel
+        results = Album.classify(array)
+        expect(results.first.class).to eq Album
       end
     end
 
     describe "all" do
       it "should return a list of airtable records" do
-        records = TestModel.all
+        records = Album.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
+        records = Album.where(color: "red")
+        expect(records.first.class).to eq Album
         expect(records.first.color).to eq "red"
       end
     end
 
     describe "find" do
       it "should call airtable-ruby's 'find' method when passed just one record ID" do
-        stub_airtable_response! "https://api.airtable.com/v0/appXYZ/example_table/recABC", { "id":"recABC", fields: {"name": "example record"} }
-        record = TestModel.find("recABC")
+        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"
       end
       it "should return an ordered list of records when passed an array of record IDs" do
-        records = TestModel.find(["recABC", "recXYZ"])
+        records = Album.find(["recABC", "recXYZ"])
         expect(records.class).to eq Array
         expect(records.first.id).to eq "recABC"
+        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/example_table"),
+          Regexp.new("https://api.airtable.com/v0/appXYZ/albums"),
           { "records" => [{"id":"recABC", fields: {"color": "blue"} }] }
         )
-        record = TestModel.find_by(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/example_table/recABC", { "id":"recABC", fields: {"name": "example record"} }
-        record = TestModel.find_by(id: "recABC")
+        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"
+        expect(record.class).to eq Album
       end
     end
 
     describe "first" do
       it "should return the first record" do
-        record = TestModel.first
-        expect(record.class).to eq TestModel
+        record = Album.first
+        expect(record.class).to eq Album
       end
     end
 
     describe "create" do
       it "should create a new record" do
-        record = TestModel.create(color: "red")
+        record = Album.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"),
+        stub_airtable_response!(Regexp.new("/v0/appXYZ/albums/12345"),
           { "fields" => { "color" => "blue", "foo" => "bar" }, "id" => "12345" },
           :patch
         )
-        record = TestModel.create(color: "red")
-        record = TestModel.patch("12345", { color: "blue" })
+        record = Album.create(color: "red")
+        record = Album.patch("12345", { color: "blue" })
         expect(record.color).to eq "blue"
       end
     end
@@ -131,17 +125,17 @@ describe TestModel do
   describe "Instance Methods" do
 
     describe "save" do
-      record = TestModel.new(color: "red")
+      record = Album.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",
+        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/example_table/12345",
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
           { "fields" => { "color" => "blue" }, "id" => "12345" },
           :patch
         )
@@ -153,22 +147,22 @@ describe TestModel do
 
     describe "destroy" do
       it "should delete a record" do
-        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/example_table/12345",
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
           { "deleted": true, "id" => "12345" },
           :delete
         )
-        response = TestModel.new(id: "12345").destroy
+        response = Album.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",
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
           { "fields" => { "color" => "green"}, "id" => "12345" },
           :patch
         )
-        record = TestModel.create(color: "red", id:"12345")
+        record = Album.create(color: "red", id:"12345")
         record.update(color: "green")
         expect(record.color).to eq "green"
       end
@@ -176,18 +170,18 @@ describe TestModel do
 
     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"
+        record = Album.new(id: "recZXY")
+        expect(record.cache_key).to eq "albums_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",
+        stub_airtable_response!("https://api.airtable.com/v0/appXYZ/albums/12345",
           { fields: { 'color': 'red' }, "id" => "12345" },
           :get
         )
-        record = TestModel.create(color: 'red')
+        record = Album.create(color: 'red')
         record[:color] = 'green'
         expect(record.changed_fields).to have_key 'color'
       end
@@ -195,7 +189,7 @@ describe TestModel do
 
     describe "new_record?" do
       it "should return true if the record hasn't been saved to airtable yet" do
-        record = TestModel.new(color: 'red')
+        record = Album.new(color: 'red')
         expect(record.new_record?).to eq true
       end
     end
@@ -208,7 +202,7 @@ describe TestModel do
         "truthy_string": "true",
         "falsy_string": "false"
       }
-      record = TestModel.new(attrs)
+      record = Album.new(attrs)
       formatted_attrs = record.formatted_fields
       it "should convert empty arrays [''] to []" do
         expect(formatted_attrs["empty_array"]).to eq []
@@ -228,60 +222,13 @@ describe TestModel do
   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
+class BaselessModel < Airmodel::Model
 end
 
-describe BaselessTestModel do
+describe BaselessModel do
   describe "it should raise a NoSuchBaseError when no base is defined" do
     begin
-      records = BaselessTestModel.some
+      records = BaselessModel.all
       false
     rescue Airmodel::NoSuchBase
       true

data/spec/query_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+class Album < Airmodel::Model
+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)
+      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
+    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
+      expect(q.all.class).to be Array
+    end
+  end
+
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: airmodel
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - chrisfrankdotfm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-21 00:00:00.000000000 Z
+date: 2016-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,11 +122,15 @@ files:
 - airmodel.gemspec
 - config/bases.yml
 - lib/airmodel.rb
+- lib/airmodel/associable.rb
 - lib/airmodel/model.rb
+- lib/airmodel/query.rb
 - lib/airmodel/utils.rb
 - lib/airmodel/version.rb
 - spec/airmodel_spec.rb
-- spec/models_spec.rb
+- spec/associable_spec.rb
+- spec/model_spec.rb
+- spec/query_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/chrisfrank/airmodel
 licenses:
@@ -148,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Interact with your Airtable data using ActiveRecord-style models