quickbase_record 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OGE4NWIyZGU4ZTNmZGFmMGRjNzdiMzA5ZDZlMzc1NTdmMTJhNzYxNg==
+  data.tar.gz: !binary |-
+    ZGExMTQ3ZWNiMzllNDk3NzEyODhkN2FlOWY3Mjk4YTc4MGU2NzU3Yg==
+SHA512:
+  metadata.gz: !binary |-
+    MzkyNTJiNWM2NmY3OTNhNTQ1NTJiNjY4NjBmNjExMjZkMzQwOTc2MTFhZmIx
+    NTkxZmU2NDc2NjY1MjIwNWI3Y2YwZWM3ZjZhMjYyZDc1MTM4N2I1MmI5N2Nl
+    YzBmOTc3MzMwMGQ1OGJlN2VhOTFiOTZhZTJkZjk0MWUyYTA3OGY=
+  data.tar.gz: !binary |-
+    N2ZhNjUzNTIwNDRiMjgyNmYwOTBmMDkyY2Y0OTFmYjM4NWI5MTY0YzZhNjEw
+    NThmZmIxZjc0MjAxNDQ4NWU2MGRjYmZkZDc0Njk2MmVkYjM1NThjZTVlNTkw
+    YWJmZTdiNTk5ZmIzM2ViMzkzM2FlNjNmOWU5MzEwNjE3YmYwMjM=

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require quickbase_record
+--require quickbase_record_config

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in quickbase_record.gemspec
+gemspec
+
+gem 'activesupport'
+gem 'activemodel'
+gem 'advantage_quickbase'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Cullen Jett
+
+MIT License
+
+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,186 @@
+# QuickbaseRecord
+
+QuickbaseRecord is a baller ActiveRecord-style ORM for using the Intuit QuickBase platform as a database for Ruby or Ruby on Rails applications.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quickbase_record'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quickbase_record
+
+## Usage
+
+### Initialize the API Client
+QuickbaseRecord is built on top of the [Advantage Quickbase](https://github.com/AdvantageIntegratedSolutions/Quickbase-Gem) gem to make the API calls to QuickBase, so you'll need to configure QuickbaseRecord with your app's realm name and provide a valid username and password. This can be done in a single initializer file with a call to `QuickbaseRecords.configure`, making sure to keep your credentials safe from the world.
+
+```
+  # config/initializers/quickbase_record.rb
+
+  QuickbaseRecord.configure do |config|
+    config.realm = "your_apps_realm_name"
+    config.username = "valid_username" (or something like ENV["QB_USERNAME"])
+    config.password = "valid_password" (or something like ENV["QB_PASSWORD"])
+  end
+```
+
+### Include it in your Class
+Simply `include QuickbaseRecord::Model` in your class and use the `.define_fields` method to supply the table's DBID and a mapping of desired field names => QuickBase FIDs
+
+```
+  # app/models/posts.rb
+
+  class Posts
+    include QuickbaseRecord::Model
+
+    define_fields ({
+      dbid: 'abcde12345'
+      id: 3,
+      content: 7,
+      author: 8
+    })
+
+    # code...
+  end
+```
+**IMPORTANT:** You must supply a key/value pair for :dbid and :id (QuickbaseRecord uses :id instead of :record_id to look more like standard ActiveRecord models)
+
+### What You Get
+Classes that include QuickbaseRecord::Model and define their fields will have a handful of class and instance methods for interacting with your QuickBase application similar to ActiveRecord. The goal is to be able to use QuickBase as a database and treat your models the same way you would with a traditional database.
+
+```
+@post = Posts.find(1) => <Post: @id=1, @content="Amazing post content", @author: 'Cullen Jett'>
+
+--
+
+<%= form_for @post do |f| %>
+  # code...
+<% end %>
+
+--
+
+@post = Post.where(author: 'Cullen Jett').first
+@post.update_attributes(author: 'THE Cullen Jett')
+
+--
+
+etc.
+```
+
+
+Also included/extended are ActiveModel::Naming, ActiveModel::Callbacks, ActiveModel::Validations, and ActiveModel::Conversion ([see ActiveModel docs for details](https://github.com/rails/rails/tree/master/activemodel/lib/active_model)). The biggest benefit here is the availability of `.validates` on your class to validate attributes and capture invalid attributes with `#valid?`.
+
+Be aware that validations needing context from the database (i.e. `validates_uniqueness_of`) are not yet supported and will need to be implemented manually.
+
+Database callbacks (i.e. `before_save :create_token!`) are not fully functional yet, so stay tuned.
+
+## Available Methods
+  * **.create(attributes_hash)**
+    - Intantiate *and* save a new object with the given attributes
+    - Assigns the returned object it's new ID
+    ```
+      Posts.create(content: 'Amazing post content', author: 'Cullen Jett')
+    ```
+
+  * **.find(id)**
+    - Query for a specific QuickBase record by it's ID
+    - Returns a single object
+    ```
+      Posts.find(params[:id])
+    ```
+
+  * **.where(attributes_hash)**
+    - Query QuickBase by any field name defined in your class' field mapping
+    - Returns an array of objects
+    ```
+      Posts.where(author: 'Cullen Jett').first
+    ```
+
+    - Multiple field_name/value pairs are joined with 'AND'
+    ```
+      Posts.where(id: 1, author: 'Cullen Jett')
+      # {'3'.EX.'1'}AND{'8'.EX.'Cullen Jett'}
+    ```
+
+    - Values in an array are joined with 'OR'
+    ```
+      Posts.where(author: ['Cullen Jett', 'Socrates')
+      # {'8'.EX.'Socrates'}OR{'8'.EX.'Socrates'}
+    ```
+
+    - To use a comparitor other than 'EX' pass the value as another hash with the key as the comparitor
+    ```
+      Posts.where(author: {XEX: 'Cullen Jett'})
+      # {'8'.XEX.'Cullen Jett'}
+    ```
+
+  * **.query(qb_query_string)**
+    - Accepts a string in the standard QuickBase query format
+    - Returns an array of objects
+    - Works with field names or FIDs
+    ```
+      Posts.query("{'3'.EX.'1'}")
+      Posts.query("{author.XEX.'Cullen Jett'}")
+    ```
+
+  * **#save**
+    - Creates a new record in QuickBase for objects that don't have an ID *or* edits the corresponding QuickBase record if the object already has an ID
+    - Returns the object (if #save created a record in QuickBase the the returned object will now have an ID)
+    - Uses API_ImportFromCSV under the hood.
+    ```
+      @post = Posts.new(content: 'Amazing post content', author: 'Cullen Jett')
+      @post.save # => <Post: @id: 1, @content: 'Amazing post content', @author: 'Cullen Jett'
+
+      @post.author = 'Socrates'
+      @post.save # => <Post: @id: 1, @content: 'Amazing post content', @author: 'Socrates'
+    ```
+
+  * **#delete**
+    - Delete the corresponding record in QuickBase
+    - It returns the object's ID if successful or `false` if unsuccessful
+    ```
+      @post = Post.find(1)
+      @post.delete
+    ```
+
+  * **#update_attributes(attributes_hash)**
+    - Updates *and* saves the object with the new attributes
+    - Returns the object
+    ```
+      @post = Posts.where(author: 'Cullen Jett').first
+      @post.update_attributes(author: 'Socrates', content: 'Something enlightening...') # => <Post: @id: 1, @author: 'Socrates', @content: 'Something enlightening...'
+    ```
+
+  * **#assign_attributes(attributes_hash)**
+    - Only changes the objects attributes in memory (i.e. does not save to QuickBase)
+    - Useful for assigning multiple attributes at once, otherwise you could use the field name's attr_accessor to change a single attribute.
+    - Returns the object
+    ```
+      @post = Posts.where(author: 'Cullen Jett').first
+      @post.assign_attributes(author: 'Socrates', content: 'Something enlightening...')
+      @post.save
+    ```
+
+## Testing
+Unfortunately you will not be able to run the test suite unless you have access to the QuickBase application used as the test database *or* you create your own QuickBase app to test against that mimics the test fakes. Eventually the test calls will be stubbed out so anyone can test it, but I've got stuff to do -- pull requests are welcome :)
+
+As of now the tests serve more as documentation for those who don't have access to the testing QuickBase app.
+
+If you're lucky enough to work with me then I can grant you access to the app and you can run the suite until your fingers bleed. You'll just need to modify `spec/quickbase_record_config.rb` to use your own credentials.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/quickbase_record/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/quickbase_record.rb

@@ -0,0 +1,23 @@
+require "quickbase_record/version"
+require 'active_support/all'
+require 'active_model'
+require 'quickbase' # This is the file name for the 'advantage_quickbase' gem. Idk why Ben named it this way...
+require_relative 'quickbase_record/configuration'
+require_relative 'quickbase_record/field_mapping'
+require_relative 'quickbase_record/client'
+require_relative 'quickbase_record/queries'
+require_relative 'quickbase_record/model'
+
+module QuickbaseRecord
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/quickbase_record/client.rb

@@ -0,0 +1,20 @@
+module QuickbaseRecord
+  module Client
+    include ActiveSupport::Concern
+
+    module ClassMethods
+      def qb_client
+        self.new.qb_client
+      end
+    end
+
+    def qb_client
+      realm = QuickbaseRecord.configuration.realm
+      username = QuickbaseRecord.configuration.username
+      password = QuickbaseRecord.configuration.password
+
+      @qb_client ||= AdvantageQuickbase::API.new(realm, username, password)
+    end
+
+  end
+end

data/lib/quickbase_record/configuration.rb

@@ -0,0 +1,11 @@
+module QuickbaseRecord
+  class Configuration
+    attr_accessor :realm, :username, :password
+
+    def initialize
+      @realm = ''
+      @username = ''
+      @password = ''
+    end
+  end
+end

data/lib/quickbase_record/field_mapping.rb

@@ -0,0 +1,9 @@
+module QuickbaseRecord
+  class FieldMapping
+    attr_accessor :fields
+
+    def initialize(fields={})
+      @fields = fields
+    end
+  end
+end

data/lib/quickbase_record/model.rb

@@ -0,0 +1,64 @@
+module QuickbaseRecord
+  module Model
+    extend ActiveSupport::Concern
+    include QuickbaseRecord::Queries
+    include QuickbaseRecord::Client
+
+    included do
+      extend QuickbaseRecord::Queries
+      extend ActiveModel::Naming
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations
+      include ActiveModel::Conversion
+    end
+
+    module ClassMethods
+      def fields(fields_hash={})
+        @fields ||= FieldMapping.new(fields_hash).fields
+      end
+
+      def define_fields(fields)
+        fields(fields)
+      end
+    end
+
+    def initialize(attributes={})
+      create_attr_accesssors
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    def persisted?
+      false
+    end
+
+    def create_attr_accesssors
+      self.class.fields.each do |field_name, fid|
+        self.class.send(:attr_accessor, field_name)
+      end
+    end
+
+    def assign_attributes(new_attributes)
+      if !new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      end
+      return if new_attributes.blank?
+
+      attributes = new_attributes.stringify_keys
+      _assign_attributes(attributes)
+    end
+
+    def _assign_attributes(attributes)
+      attributes.each do |k, v|
+        _assign_attribute(k, v)
+      end
+    end
+
+    def _assign_attribute(k, v)
+      if respond_to?("#{k}=")
+        public_send("#{k}=", v)
+      end
+    end
+  end
+end

data/lib/quickbase_record/queries.rb

@@ -0,0 +1,166 @@
+require_relative 'client'
+
+module QuickbaseRecord
+  module Queries
+    extend ActiveSupport::Concern
+    include QuickbaseRecord::Client
+
+    UNWRITABLE_FIELDS = ['dbid', 'id', 'date_created', 'date_modified', 'record_owner', 'last_modified_by']
+
+    module ClassMethods
+      def dbid
+        @dbid ||= fields[:dbid]
+      end
+
+      def clist
+        @clist ||= fields.reject{ |field_name| field_name == :dbid }.values.join('.')
+      end
+
+      def find(id)
+        query_options = { query: build_query(id: id), clist: clist }
+        query_response = qb_client.do_query(dbid, query_options).first
+        converted_response = convert_quickbase_response(query_response)
+
+        new(converted_response)
+      end
+
+      def where(query_hash)
+        query_options = { query: build_query(query_hash), clist: clist }
+        query_response = qb_client.do_query(dbid, query_options)
+
+        array_of_new_objects = query_response.map do |response|
+          converted_response = convert_quickbase_response(response)
+          new(converted_response)
+        end
+
+        return array_of_new_objects
+      end
+
+      def create(attributes={})
+        raise StandardErrror, "You cannot call #{self}.create() with an :id attribute" if attributes.include?(:id)
+        object = new(attributes)
+        object.save
+        return object
+      end
+
+      def query(query_string)
+        query_options = { query: build_query(query_string), clist: clist }
+        query_response = qb_client.do_query(dbid, query_options)
+
+        array_of_new_objects = query_response.map do |response|
+          converted_response = convert_quickbase_response(response)
+          new(converted_response)
+        end
+
+        return array_of_new_objects
+      end
+
+      def build_query(query_hash)
+        return convert_query_string(query_hash) if query_hash.is_a? String
+
+        query_hash.map do |field_name, values|
+          fid = convert_field_name_to_fid(field_name)
+          if values.is_a? Array
+            join_with_or(fid, values)
+          elsif values.is_a? Hash
+            join_with_custom(fid, values)
+          else
+            join_with_and(fid, values)
+          end
+        end.join("AND")
+      end
+
+      private
+
+      def join_with_and(fid, value, comparitor="EX")
+        "{'#{fid}'.#{comparitor}.'#{value}'}"
+      end
+
+      def join_with_or(fid, array, comparitor="EX")
+        array.map do |value|
+          "{'#{fid}'.#{comparitor}.'#{value}'}"
+        end.join("OR")
+      end
+
+      def join_with_custom(fid, hash)
+        comparitor = hash.keys.first
+        value = hash.values.first
+
+        if value.is_a? Array
+          join_with_or(fid, value, comparitor)
+        else
+          "{'#{fid}'.#{comparitor}.'#{value}'}"
+        end
+
+      end
+
+      def convert_field_name_to_fid(field_name)
+        self.fields[field_name.to_sym].to_s
+      end
+
+      def covert_fid_to_field_name(fid)
+        self.fields.invert[fid.to_i]
+      end
+
+      def convert_quickbase_response(response)
+        result = {}
+
+        response.each do |fid, value|
+          field_name = covert_fid_to_field_name(fid)
+          result[field_name] = value
+        end
+
+        result
+      end
+
+      def convert_query_string(query_string)
+        match_found = false
+
+        uses_field_name = query_string.match(/\{'?(.*)'?\..*\.'?.*'?\}/)[1].to_i == 0
+
+        if !uses_field_name
+          return query_string
+        end
+
+        fields.each do |field_name, fid|
+          field_name = field_name.to_s
+          match_string = "\{'?(#{field_name})'?\..*\.'?.*'?\}"
+          if query_string.scan(/#{match_string}/).length > 0
+            query_string.gsub!(field_name, fid.to_s)
+            match_found = true
+          end
+        end
+
+        if !match_found
+          raise ArgumentError, "Invalid arguments on #{self}.query() - no matching field name found. \nMake sure the field is part of your class configuration."
+        end
+
+        query_string
+      end
+    end
+
+    # INSTANCE METHODS
+    def save
+      current_object = {}
+      self.class.fields.each do |field_name, fid|
+        current_object[fid] = public_send(field_name) unless UNWRITABLE_FIELDS.include?(field_name.to_s)
+        current_object[self.class.fields[:id]] = self.id if self.id
+      end
+      self.id = qb_client.import_from_csv(self.class.dbid, [current_object]).first
+    end
+
+    def delete
+      return false if !self.id
+
+      successful = qb_client.delete_record(self.class.dbid, self.id)
+
+      return successful ? self.id : false
+    end
+
+    def update_attributes(attributes={})
+      self.assign_attributes(attributes)
+      self.save
+      return self
+    end
+  end
+end

data/lib/quickbase_record/version.rb

@@ -0,0 +1,3 @@
+module QuickbaseRecord
+  VERSION = "0.0.1"
+end

data/quickbase_record.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quickbase_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quickbase_record"
+  spec.version       = QuickbaseRecord::VERSION
+  spec.authors       = ["Cullen Jett"]
+  spec.email         = ["cullenjett@gmail.com"]
+  spec.summary       = "An ActiveRecord-style ORM for using Intuit QuickBase tables as models."
+  spec.description   = "QuickbaseRecord is a baller ActiveRecord-style ORM for using the Intuit QuickBase platform as a database for Ruby or Ruby on Rails applications."
+  spec.homepage      = "https://github.com/cullenjett/quickbase_record"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "shoulda-matchers"
+
+  spec.add_runtime_dependency "advantage_quickbase"
+  spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "activemodel"
+end

data/spec/fakes/student_fake.rb

@@ -0,0 +1,13 @@
+require './lib/quickbase_record'
+
+class StudentFake
+  include QuickbaseRecord::Model
+
+  StudentFake.define_fields ({
+    :dbid => 'bjzrx8ckw',
+    :id => 3,
+    :name => 6,
+    :grade => 7,
+    :email => 8
+  })
+end

data/spec/fakes/teacher_fake.rb

@@ -0,0 +1,14 @@
+require './lib/quickbase_record'
+
+class TeacherFake
+  include QuickbaseRecord::Model
+
+  define_fields ({
+    :dbid => "bjzrx8cjn",
+    :id => 3,
+    :name => 6,
+    :subject => 7,
+    :salary => 8
+  })
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,30 @@
+require './spec/fakes/student_fake'
+
+RSpec.describe QuickbaseRecord::Model do
+  describe '.define_fields' do
+    it "sets the class field mappings for field names => FIDs" do
+      StudentFake.define_fields ({
+        :dbid => 'bjzrx8ckw',
+        :id => 3,
+        :name => 6,
+        :grade => 7,
+        :email => 8
+      })
+
+      expect(StudentFake.fields[:id]).to eq(3)
+    end
+  end
+
+  describe 'initialize' do
+    it "dynamically creates attr_accessors for the class based on the configuration fields" do
+      student = StudentFake.new(name: 'Cullen Jett')
+      expect(student.respond_to?(:name)).to be true
+      expect(student.respond_to?(:name=)).to be true
+    end
+
+    it "assigns passed in attributes to itself" do
+      student = StudentFake.new(name: 'Cullen Jett')
+      expect(student.name).to eq('Cullen Jett')
+    end
+  end
+end

data/spec/queries_spec.rb

@@ -0,0 +1,156 @@
+require './spec/fakes/teacher_fake'
+
+RSpec.describe QuickbaseRecord::Queries do
+  describe '.find' do
+    it "finds a single Teacher given an ID" do
+      teacher = TeacherFake.find(1)
+      expect(teacher.id).to eq("1")
+    end
+
+    it "returns an object of the Teacher class" do
+      teacher = TeacherFake.find(1)
+      expect(teacher).to be_a TeacherFake
+    end
+  end
+
+  describe '.where' do
+    it "returns an array of objects" do
+      teachers = TeacherFake.where(id: 1)
+      expect(teachers).to be_a Array
+    end
+
+    it "returns an object of the Teacher class" do
+      teachers = TeacherFake.where(id: 1)
+      expect(teachers.first).to be_a TeacherFake
+    end
+  end
+
+  describe '.create' do
+    it "saves the object immediately" do
+      teacher = TeacherFake.create(name: 'Professor Dumbledore')
+      expect(teacher.id).to be > 1
+      teacher.delete
+    end
+
+    it "throws an error if an :id argument is passed" do
+      expect { TeacherFake.create(id: 1, name: 'Professor Dumbledore') }.to raise_error
+    end
+  end
+
+  describe '.query' do
+    it "returns an array of objects" do
+      teachers = TeacherFake.query("{id.EX.'1'}")
+      expect(teachers).to be_a Array
+    end
+
+    it "returns an object of the Teacher class" do
+      teachers = TeacherFake.query("{id.EX.'1'}")
+      expect(teachers.first).to be_a TeacherFake
+    end
+
+    it "accepts FIDs instead of field names" do
+      teachers = TeacherFake.query("{'3'.EX.'1'}")
+      expect(teachers.first.id).to eq('1')
+    end
+  end
+
+  describe '#save' do
+    it "creates a new record for an object without an ID and sets it's new ID" do
+      cullen = TeacherFake.new(name: 'Cullen Jett', salary: '1,000,000.00')
+      new_id = cullen.save
+      expect(new_id).to be_truthy
+      expect(cullen.id).to eq(new_id)
+    end
+
+    it "edits an object that has an existing ID" do
+      cullen = TeacherFake.where(name: 'Cullen Jett').first
+      cullen.subject = 'Ruby on Rails'
+      cullen.name = "THE #{cullen.name}"
+      expect(cullen.save).to be_truthy
+      cullen.delete
+    end
+  end
+
+  describe '#delete' do
+    it "deletes an object from QuickBase" do
+      socrates = TeacherFake.new(name: 'Socrates')
+      socrates.save
+      old_id = socrates.id
+      expect(socrates.delete).to eq(old_id)
+    end
+
+    it "returns false if the object doesn't yet have an ID" do
+      expect(TeacherFake.new(name: 'Socrates').delete).to be false
+    end
+  end
+
+  describe '#assign_attributes' do
+    it "assigns an objects attributes given a hash attributes and their values" do
+      teacher = TeacherFake.new(name: 'teacher1', salary: 35000)
+      teacher.assign_attributes(name: 'teacher2', salary: 40000)
+      expect(teacher.name).to eq('teacher2')
+      expect(teacher.salary).to eq(40000)
+    end
+
+    it "doesn't save the object" do
+      teacher = TeacherFake.new(name: 'teacher1', salary: 35000)
+      teacher.assign_attributes(name: 'teacher2', salary: 40000)
+      expect(teacher.id).to be_falsey
+    end
+  end
+
+  describe '#update_attributes' do
+    it "assigns an objects attributes given a hash attributes and their values" do
+      teacher = TeacherFake.new(name: 'teacher1', salary: 35000)
+      teacher.update_attributes(name: 'teacher2', salary: 40000)
+      expect(teacher.name).to eq('teacher2')
+      expect(teacher.salary).to eq(40000)
+    end
+
+    it "saves the object" do
+      teacher = TeacherFake.new(name: 'teacher1', salary: 35000)
+      teacher.update_attributes(name: 'teacher2', salary: 40000)
+      expect(teacher.id).to be_truthy
+      teacher.delete
+    end
+  end
+
+  # This is sort of a private method, but it seems pretty important so I'm keeping these tests.
+  # It could probably stand to be extracted into a separate class...
+  describe '.build_query' do
+    it "converts a hash into QuickBase query format with EX as the default comparitor" do
+      hash = {id: 1}
+      expect(TeacherFake.build_query(hash)).to eq("{'3'.EX.'1'}")
+    end
+
+    it "combines multiple key/value pairs with AND" do
+      hash = {id: 1, name: 'Mrs. Brown'}
+      expect(TeacherFake.build_query(hash)).to eq("{'3'.EX.'1'}AND{'6'.EX.'Mrs. Brown'}")
+    end
+
+    it "combines values that are arrays with OR" do
+      hash = {id: [1, 2]}
+      expect(TeacherFake.build_query(hash)).to eq("{'3'.EX.'1'}OR{'3'.EX.'2'}")
+    end
+
+    it "accepts custom comparitors via a nested hash" do
+      hash = {id: {XEX: 1}}
+      expect(TeacherFake.build_query(hash)).to eq("{'3'.XEX.'1'}")
+    end
+
+    it "combines custom comparitors using arrays with OR" do
+      hash = {id: {XEX: [1, 2]}}
+      expect(TeacherFake.build_query(hash)).to eq("{'3'.XEX.'1'}OR{'3'.XEX.'2'}")
+    end
+
+    it "converts field names to FIDs" do
+      hash = "{name.EX.'Cullen Jett'}"
+      expect(TeacherFake.build_query(hash)).to eq("{6.EX.'Cullen Jett'}")
+    end
+
+    it "throws an error for invaid field names" do
+      hash = "{not_a_field_name.EX.'Cullen Jett'}"
+      expect { TeacherFake.build_query(hash) }.to raise_error
+    end
+  end
+end

data/spec/quickbase_record_config.rb

@@ -0,0 +1,5 @@
+QuickbaseRecord.configure do |config|
+  config.realm = "ais"
+  config.username = ENV["QB_USERNAME"]
+  config.password = ENV["QB_PASSWORD"]
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: quickbase_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cullen Jett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  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'
+- !ruby/object:Gem::Dependency
+  name: advantage_quickbase
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: QuickbaseRecord is a baller ActiveRecord-style ORM for using the Intuit
+  QuickBase platform as a database for Ruby or Ruby on Rails applications.
+email:
+- cullenjett@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/quickbase_record.rb
+- lib/quickbase_record/client.rb
+- lib/quickbase_record/configuration.rb
+- lib/quickbase_record/field_mapping.rb
+- lib/quickbase_record/model.rb
+- lib/quickbase_record/queries.rb
+- lib/quickbase_record/version.rb
+- quickbase_record.gemspec
+- spec/fakes/student_fake.rb
+- spec/fakes/teacher_fake.rb
+- spec/model_spec.rb
+- spec/queries_spec.rb
+- spec/quickbase_record_config.rb
+homepage: https://github.com/cullenjett/quickbase_record
+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.4.2
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord-style ORM for using Intuit QuickBase tables as models.
+test_files:
+- spec/fakes/student_fake.rb
+- spec/fakes/teacher_fake.rb
+- spec/model_spec.rb
+- spec/queries_spec.rb
+- spec/quickbase_record_config.rb