airrecord 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6488c3737cb574a3e1e5e1cbc1d5ae665482c364
-  data.tar.gz: 8ebba576595589c7d8e9c6558d9e2032d6953507
+  metadata.gz: 34c528021b09a5445d86bdf54f171f09874a1fe7
+  data.tar.gz: e854c5670ed5e96c1bd66effa1538f5c522becb3
 SHA512:
-  metadata.gz: 16a9ffc9fc7ec8a69061e7b26041410c3fcdba2bd2bb1b21f3034cc9f3f60a88dd0b8370118ed167595ba3e4a7aa51780987e74d6176d737736989c0c966fbb4
-  data.tar.gz: 998c84a7691409db02f09bb65479e7ebfe1e9a33b820dec3da333083751f4ca0031e892708e438dc63097bf4b39847c5b4143ccb631d3ed70ec76742996319a4
+  metadata.gz: 63b9fc0ad061aa526a5b117d8db1477e9260730e74f4656728f23c857b629ed4d5aefcde96a8f516c25a079476338087fe89711f04b93df9201607893ba6058f
+  data.tar.gz: 1cde11c40f0d44d55e5f2519b5505228595f67fd3343a0cdc620feb2d11ae4edeba29e4cc8ce04e9a31d3ee778e87989ffc51d09cca444a469848a04379e4881

data/airrecord.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'faraday', '~> 0.10.0'
-  spec.add_dependency "net-http-persistent", '~> 2.9.4'
+  spec.add_dependency 'faraday', '~> 0.10'
+  spec.add_dependency "net-http-persistent", '~> 2.9'
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/airrecord.rb

@@ -1,309 +1,9 @@
-require "airrecord/version"
 require "json"
 require "faraday"
+require "airrecord/version"
+require "airrecord/client"
+require "airrecord/table"
 
 module Airrecord
   Error = Class.new(StandardError)
-
-  # TODO: This would be much simplified if we had a schema instead. Hopefully
-  # one day Airtable will add this, but to simplify and crush the majority of
-  # the bugs that hide in here (which would be related to the dynamic schema) we
-  # may just query the first page and infer a schema from there that can be
-  # overridden on the specific classes.
-  #
-  # Right now I bet there's a bunch of bugs around similar named column keys (in
-  # terms of capitalization), it's inconsistent and non-obvious that `create`
-  # doesn't use the same column keys as everything else.
-  class Table
-    class << self
-      attr_accessor :base_key, :table_name, :api_key, :associations
-
-      def client
-        @@client ||= Client.new(api_key)
-      end
-
-      def has_many(name, options)
-        @associations ||= []
-        @associations << {
-          field: name.to_sym,
-        }.merge(options)
-      end
-
-      def belongs_to(name, options)
-        has_many(name, options.merge(single: true))
-      end
-
-      def find(id)
-        response = client.connection.get("/v0/#{base_key}/#{client.escape(table_name)}/#{id}")
-        parsed_response = client.parse(response.body)
-
-        if response.success?
-          self.new(parsed_response["fields"], id: id)
-        else
-          client.handle_error(response.status, parsed_response)
-        end
-      end
-
-      def schema
-        # handle associations as specific field type
-        # TODO: what if there's an overlap in alias and keys??
-        schema = {}
-
-        records(paginate: false).each do |record|
-          record.fields.keys.each do |key|
-            unless schema.find { |column| column[:key] == key }
-              schema[key] = {
-                key: key,
-                type: :field,
-                alias: underscore(key),
-              }
-            end
-          end
-        end
-
-        if @associations
-          @associations.each do |assoc|
-            schema[assoc[:field]][:type] = :association
-          end
-        end
-
-        schema
-      end
-
-      def records(filter: nil, sort: nil, view: nil, offset: nil, paginate: true, fields: nil)
-        options = {}
-        options[:filterByFormula] = filter if filter
-
-        if sort
-          options[:sort] = sort.map { |field, direction|
-            { field: field.to_s, direction: direction }
-          }
-        end
-
-        options[:view] = view if view
-        options[:offset] = offset if offset
-        options[:fields] = fields if fields
-
-        path = "/v0/#{base_key}/#{client.escape(table_name)}"
-        response = client.connection.get(path, options)
-        parsed_response = client.parse(response.body)
-
-        if response.success?
-          records = parsed_response["records"]
-          records = records.map { |record|
-            self.new(record["fields"], id: record["id"], created_at: record["createdTime"])
-          }
-
-          if paginate && parsed_response["offset"]
-            records.concat(records(
-              filter: filter,
-              sort: sort,
-              view: view,
-              paginate: paginate,
-              fields: fields,
-              offset: parsed_response["offset"],
-            ))
-          end
-
-          records
-        else
-          client.handle_error(response.status, parsed_response)
-        end
-      end
-      alias_method :all, :records
-    end
-
-    attr_reader :fields, :column_mappings, :id, :created_at, :updated_fields
-
-    def initialize(fields, id: nil, created_at: nil)
-      @id = id
-      self.created_at = created_at
-      self.fields = fields
-    end
-
-    def new_record?
-      !id
-    end
-
-    def [](key)
-      value = nil
-
-      if fields[key]
-        value = fields[key]
-      elsif column_mappings[key]
-        value = fields[column_mappings[key]]
-      end
-
-      if association = self.association(key)
-        klass = Kernel.const_get(association[:class])
-        associations = value.map { |id_or_obj|
-          id_or_obj = id_or_obj.respond_to?(:id) ? id_or_obj.id : id_or_obj
-          klass.find(id_or_obj)
-        }
-        return associations.first if association[:single]
-        associations
-      else
-        type_cast(value)
-      end
-    end
-
-    def []=(key, value)
-      if fields[key]
-        @updated_keys << key
-        fields[key] = value
-      elsif column_mappings[key]
-        @updated_keys << column_mappings[key]
-        fields[column_mappings[key]] = value
-      else
-        @updated_keys << key
-        fields[key] = value
-      end
-    end
-
-    def create
-      raise Error, "Record already exists" unless new_record?
-
-      body = { fields: serializable_fields }.to_json
-      response = client.connection.post("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}", body, { 'Content-Type': 'application/json' })
-      parsed_response = client.parse(response.body)
-
-      if response.success?
-        @id = parsed_response["id"]
-        self.created_at = parsed_response["createdTime"]
-        self.fields = parsed_response["fields"]
-      else
-        client.handle_error(response.status, parsed_response)
-      end
-    end
-
-    def save
-      raise Error, "Unable to save a new record" if new_record?
-
-      return true if @updated_keys.empty?
-
-      # To avoid trying to update computed fields we *always* use PATCH
-      body = {
-        fields: Hash[@updated_keys.map { |key|
-          [key, fields[key]]
-        }]
-      }.to_json
-
-      response = client.connection.patch("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}", body, { 'Content-Type': 'application/json' })
-      parsed_response = client.parse(response.body)
-
-      if response.success?
-        self.fields = parsed_response
-      else
-        client.handle_error(response.status, parsed_response)
-      end
-    end
-
-    def destroy
-      raise Error, "Unable to destroy new record" if new_record?
-
-      response = client.connection.delete("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}")
-      parsed_response = client.parse(response.body)
-
-      if response.success?
-        true
-      else
-        client.handle_error(response.status, parsed_response)
-      end
-    end
-
-    def serializable_fields(fields = self.fields)
-      Hash[fields.map { |(key, value)|
-        if association(key)
-          [key, value.map(&:id)]
-        else
-          [key, value]
-        end
-      }]
-    end
-
-    protected
-
-    def association(key)
-      if self.class.associations
-        self.class.associations.find { |association|
-          association[:column].to_s == column_mappings[key].to_s || association[:column].to_s == key.to_s
-        }
-      end
-    end
-
-    def fields=(fields)
-      @updated_keys = []
-      @column_mappings = Hash[fields.keys.map { |key| [underscore(key), key] }]
-      @fields = fields
-    end
-
-    def self.underscore(key)
-      key.to_s.strip.gsub(/\W+/, "_").downcase.to_sym
-    end
-
-    def underscore(key)
-      self.class.underscore(key)
-    end
-
-    def created_at=(created_at)
-      return unless created_at
-      @created_at = Time.parse(created_at)
-    end
-
-    def client
-      self.class.client
-    end
-
-    def type_cast(value)
-      if value =~ /\d{4}-\d{2}-\d{2}/
-        Time.parse(value + " UTC")
-      else
-        value
-      end
-    end
-  end
-
-  def self.table(api_key, base_key, table_name)
-    Class.new(Table) do |klass|
-      klass.table_name = table_name
-      klass.api_key = api_key
-      klass.base_key = base_key
-    end
-  end
-
-  class Client
-    attr_reader :api_key
-    attr_writer :connection
-
-    def initialize(api_key)
-      @api_key = api_key
-    end
-
-    def connection
-      @connection ||= Faraday.new(url: "https://api.airtable.com", headers: {
-        "Authorization" => "Bearer #{api_key}",
-        "X-API-VERSION" => "0.1.0",
-      }) { |conn|
-        conn.adapter :net_http_persistent
-      }
-    end
-
-    def escape(*args)
-      URI.escape(*args)
-    end
-
-    def parse(body)
-      JSON.parse(body)
-    rescue JSON::ParserError
-      nil
-    end
-
-    def handle_error(status, error)
-      if error.is_a?(Hash)
-        raise Error, "HTTP #{status}: #{error['error']["type"]}: #{error['error']['message']}"
-      else
-        raise Error, "HTTP #{status}: Communication error: #{error}"
-      end
-    end
-  end
 end

data/lib/airrecord/client.rb

@@ -0,0 +1,37 @@
+module Airrecord
+  class Client
+    attr_reader :api_key
+    attr_writer :connection
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: "https://api.airtable.com", headers: {
+        "Authorization" => "Bearer #{api_key}",
+        "X-API-VERSION" => "0.1.0",
+      }) { |conn|
+        conn.adapter :net_http_persistent
+      }
+    end
+
+    def escape(*args)
+      URI.escape(*args)
+    end
+
+    def parse(body)
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+
+    def handle_error(status, error)
+      if error.is_a?(Hash)
+        raise Error, "HTTP #{status}: #{error['error']["type"]}: #{error['error']['message']}"
+      else
+        raise Error, "HTTP #{status}: Communication error: #{error}"
+      end
+    end
+  end
+end

data/lib/airrecord/table.rb

@@ -0,0 +1,244 @@
+module Airrecord
+  # TODO: This would be much simplified if we had a schema instead. Hopefully
+  # one day Airtable will add this, but to simplify and crush the majority of
+  # the bugs that hide in here (which would be related to the dynamic schema) we
+  # may just query the first page and infer a schema from there that can be
+  # overridden on the specific classes.
+  #
+  # Right now I bet there's a bunch of bugs around similar named column keys (in
+  # terms of capitalization), it's inconsistent and non-obvious that `create`
+  # doesn't use the same column keys as everything else.
+  class Table
+    class << self
+      attr_accessor :base_key, :table_name, :api_key, :associations
+
+      def client
+        @@client ||= Client.new(api_key)
+      end
+
+      def has_many(name, options)
+        @associations ||= []
+        @associations << {
+          field: name.to_sym,
+        }.merge(options)
+      end
+
+      def belongs_to(name, options)
+        has_many(name, options.merge(single: true))
+      end
+
+      def find(id)
+        response = client.connection.get("/v0/#{base_key}/#{client.escape(table_name)}/#{id}")
+        parsed_response = client.parse(response.body)
+
+        if response.success?
+          self.new(parsed_response["fields"], id: id)
+        else
+          client.handle_error(response.status, parsed_response)
+        end
+      end
+
+      def records(filter: nil, sort: nil, view: nil, offset: nil, paginate: true, fields: nil)
+        options = {}
+        options[:filterByFormula] = filter if filter
+
+        if sort
+          options[:sort] = sort.map { |field, direction|
+            { field: field.to_s, direction: direction }
+          }
+        end
+
+        options[:view] = view if view
+        options[:offset] = offset if offset
+        options[:fields] = fields if fields
+
+        path = "/v0/#{base_key}/#{client.escape(table_name)}"
+        response = client.connection.get(path, options)
+        parsed_response = client.parse(response.body)
+
+        if response.success?
+          records = parsed_response["records"]
+          records = records.map { |record|
+            self.new(record["fields"], id: record["id"], created_at: record["createdTime"])
+          }
+
+          if paginate && parsed_response["offset"]
+            records.concat(records(
+              filter: filter,
+              sort: sort,
+              view: view,
+              paginate: paginate,
+              fields: fields,
+              offset: parsed_response["offset"],
+            ))
+          end
+
+          records
+        else
+          client.handle_error(response.status, parsed_response)
+        end
+      end
+      alias_method :all, :records
+    end
+
+    attr_reader :fields, :column_mappings, :id, :created_at, :updated_fields
+
+    def initialize(fields, id: nil, created_at: nil)
+      @id = id
+      self.created_at = created_at
+      self.fields = fields
+    end
+
+    def new_record?
+      !id
+    end
+
+    def [](key)
+      value = nil
+
+      if fields[key]
+        value = fields[key]
+      elsif column_mappings[key]
+        value = fields[column_mappings[key]]
+      end
+
+      if association = self.association(key)
+        klass = Kernel.const_get(association[:class])
+        associations = value.map { |id_or_obj|
+          id_or_obj = id_or_obj.respond_to?(:id) ? id_or_obj.id : id_or_obj
+          klass.find(id_or_obj)
+        }
+        return associations.first if association[:single]
+        associations
+      else
+        type_cast(value)
+      end
+    end
+
+    def []=(key, value)
+      if fields[key]
+        @updated_keys << key
+        fields[key] = value
+      elsif column_mappings[key]
+        @updated_keys << column_mappings[key]
+        fields[column_mappings[key]] = value
+      else
+        @updated_keys << key
+        fields[key] = value
+      end
+    end
+
+    def create
+      raise Error, "Record already exists (record has an id)" unless new_record?
+
+      body = { fields: serializable_fields }.to_json
+      response = client.connection.post("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}", body, { 'Content-Type': 'application/json' })
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        @id = parsed_response["id"]
+        self.created_at = parsed_response["createdTime"]
+        self.fields = parsed_response["fields"]
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def save
+      raise Error, "Unable to save a new record" if new_record?
+
+      return true if @updated_keys.empty?
+
+      # To avoid trying to update computed fields we *always* use PATCH
+      body = {
+        fields: Hash[@updated_keys.map { |key|
+          [key, fields[key]]
+        }]
+      }.to_json
+
+      response = client.connection.patch("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}", body, { 'Content-Type': 'application/json' })
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        self.fields = parsed_response
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def destroy
+      raise Error, "Unable to destroy new record" if new_record?
+
+      response = client.connection.delete("/v0/#{self.class.base_key}/#{client.escape(self.class.table_name)}/#{self.id}")
+      parsed_response = client.parse(response.body)
+
+      if response.success?
+        true
+      else
+        client.handle_error(response.status, parsed_response)
+      end
+    end
+
+    def serializable_fields(fields = self.fields)
+      Hash[fields.map { |(key, value)|
+        if association(key)
+          assocs = value.map { |assoc|
+            assoc.respond_to?(:id) ? assoc.id : assoc
+          }
+          [key, assocs]
+        else
+          [key, value]
+        end
+      }]
+    end
+
+    protected
+
+    def association(key)
+      if self.class.associations
+        self.class.associations.find { |association|
+          association[:column].to_s == column_mappings[key].to_s || association[:column].to_s == key.to_s
+        }
+      end
+    end
+
+    def fields=(fields)
+      @updated_keys = []
+      @column_mappings = Hash[fields.keys.map { |key| [underscore(key), key] }]
+      @fields = fields
+    end
+
+    def self.underscore(key)
+      key.to_s.strip.gsub(/\W+/, "_").downcase.to_sym
+    end
+
+    def underscore(key)
+      self.class.underscore(key)
+    end
+
+    def created_at=(created_at)
+      return unless created_at
+      @created_at = Time.parse(created_at)
+    end
+
+    def client
+      self.class.client
+    end
+
+    def type_cast(value)
+      if value =~ /\d{4}-\d{2}-\d{2}/
+        Time.parse(value + " UTC")
+      else
+        value
+      end
+    end
+  end
+
+  def self.table(api_key, base_key, table_name)
+    Class.new(Table) do |klass|
+      klass.table_name = table_name
+      klass.api_key = api_key
+      klass.base_key = base_key
+    end
+  end
+end

data/lib/airrecord/version.rb

@@ -1,3 +1,3 @@
 module Airrecord
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: airrecord
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Simon Eskildsen
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.9.4
+        version: '2.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.9.4
+        version: '2.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -111,6 +111,8 @@ files:
 - bin/console
 - bin/setup
 - lib/airrecord.rb
+- lib/airrecord/client.rb
+- lib/airrecord/table.rb
 - lib/airrecord/version.rb
 homepage: https://github.com/sirupsen/airtable
 licenses: []