fmrest 0.9.0 → 0.12.0

data/lib/fmrest/spyke/container_field.rb

@@ -42,7 +42,7 @@ module FmRest
           )
 
         # Update mod id on record
-        @base.mod_id = response.body[:data][:mod_id]
+        @base.__mod_id = response.body[:data][:__mod_id]
 
         true
       end
@@ -52,7 +52,7 @@ module FmRest
       # @param repetition [Integer]
       # @return [String] the path for uploading a file to the container
       def upload_path(repetition)
-        FmRest::V1.container_field_path(@base.class.layout, @base.id, name, repetition)
+        FmRest::V1.container_field_path(@base.class.layout, @base.__record_id, name, repetition)
       end
     end
   end

data/lib/fmrest/spyke/model.rb

@@ -2,6 +2,7 @@
 
 require "fmrest/spyke/model/connection"
 require "fmrest/spyke/model/uri"
+require "fmrest/spyke/model/record_id"
 require "fmrest/spyke/model/attributes"
 require "fmrest/spyke/model/serialization"
 require "fmrest/spyke/model/associations"
@@ -17,7 +18,8 @@ module FmRest
       extend ::ActiveSupport::Concern
 
       include Connection
-      include Uri
+      include URI
+      include RecordID
       include Attributes
       include Serialization
       include Associations
@@ -26,11 +28,6 @@ module FmRest
       include GlobalFields
       include Http
       include Auth
-
-      included do
-        # @return [Integer] the record's modId
-        attr_accessor :mod_id
-      end
     end
   end
 end

data/lib/fmrest/spyke/model/associations.rb

@@ -5,6 +5,8 @@ require "fmrest/spyke/portal"
 module FmRest
   module Spyke
     module Model
+      # This module adds portal support to Spyke models.
+      #
       module Associations
         extend ::ActiveSupport::Concern
 
@@ -22,17 +24,18 @@ module FmRest
         end
 
         class_methods do
-          # Based on +has_many+, but creates a special Portal association
+          # Based on `has_many`, but creates a special Portal association
           # instead.
           #
-          # Custom options:
+          # @option :portal_key [String] The key used for the portal in the FM
+          #   Data JSON portalData
+          # @option :attribute_prefix [String] The prefix used for portal
+          #   attributes in the FM Data JSON
           #
-          # * <tt>:portal_key</tt> - The key used for the portal in the FM Data JSON portalData.
-          # * <tt>:attribute_prefix</tt> - The prefix used for portal attributes in the FM Data JSON.
-          #
-          # Example:
-          #
-          #   has_portal :jobs, portal_key: "JobsTable", attribute_prefix: "Job"
+          # @example
+          #   class Person < FmRest::Spyke::Base
+          #     has_portal :jobs, portal_key: "JobsTable", attribute_prefix: "Job"
+          #   end
           #
           def has_portal(name, options = {})
             create_association(name, Portal, options)
@@ -47,9 +50,8 @@ module FmRest
           end
         end
 
-        # Override Spyke's association reader to keep a cache of loaded
-        # portals. Spyke's default behavior is to reload the association
-        # each time.
+        # Spyke override -- Keep a cache of loaded portals. Spyke's default
+        # behavior is to reload the association each time.
         #
         def association(name)
           @loaded_portals ||= {}
@@ -64,6 +66,8 @@ module FmRest
           end
         end
 
+        # Spyke override -- Add portals awareness
+        #
         def reload(*_)
           super.tap { @loaded_portals = nil }
         end

data/lib/fmrest/spyke/model/attributes.rb

@@ -5,6 +5,10 @@ require "fmrest/spyke/model/orm"
 module FmRest
   module Spyke
     module Model
+      # Extends Spyke models with support for mapped attributes,
+      # `ActiveModel::Dirty` and forbidden attributes (e.g. Rails'
+      # `params.permit`).
+      #
       module Attributes
         extend ::ActiveSupport::Concern
 
@@ -20,9 +24,6 @@ module FmRest
           # by Spyke
           self.attribute_method_matchers.shift
 
-          # ActiveModel::Dirty methods for id
-          define_attribute_method(:id)
-
           # Keep track of attribute mappings so we can get the FM field names
           # for changed attributes
           class_attribute :mapped_attributes, instance_writer: false, instance_predicate: false
@@ -36,10 +37,12 @@ module FmRest
         end
 
         class_methods do
+          # Spyke override
+          #
           # Similar to Spyke::Base.attributes, but allows defining attribute
           # methods that map to FM attributes with different names.
           #
-          # Example:
+          # @example
           #
           #   class Person < Spyke::Base
           #     include FmRest::Spyke::Model
@@ -61,9 +64,10 @@ module FmRest
 
           private
 
-          # Override Spyke::Base.new_or_return (private), called whenever
-          # loading records from the HTTP API, so we can reset dirty info on
-          # freshly loaded records
+          # Spyke override (private)
+          #
+          # Called whenever loading records from the HTTP API, so we can reset
+          # dirty info on freshly loaded records
           #
           # See: https://github.com/balvig/spyke/blob/master/lib/spyke/http.rb
           #
@@ -88,8 +92,6 @@ module FmRest
           end
 
           def _fmrest_define_attribute(from, to)
-            raise ArgumentError, "attribute name `id' is reserved for the recordId" if from.to_s == "id"
-
             # We use a setter here instead of injecting the hash key/value pair
             # directly with #[]= so that we don't change the mapped_attributes
             # hash on the parent class. The resulting hash is frozen for the
@@ -112,35 +114,25 @@ module FmRest
           end
         end
 
-        def id=(value)
-          id_will_change! unless value == id
-          super
-        end
-
+        # Spyke override -- Adds AM::Dirty support
+        #
         def reload(*args)
           super.tap { |r| clear_changes_information }
         end
 
+        # Spyke override -- Adds AM::Dirty support
+        #
         def save(*args)
           super.tap { |r| changes_applied_after_save if r }
         end
 
-        # ActiveModel::Dirty since version 5.2 assumes that if there's an
-        # @attributes instance variable set we must be using ActiveRecord, so
-        # we override the instance variable name used by Spyke to avoid issues.
-        #
-        # TODO: Submit a pull request to Spyke so this isn't needed
-        #
-        def attributes
-          @_spyke_attributes
-        end
-
-        # In addition to the comments above on `attributes`, this also adds
-        # support for forbidden attributes
+        # Spyke override -- Adds support for forbidden attributes (i.e. Rails'
+        # `params.permit`, etc.)
         #
         def attributes=(new_attributes)
-          @_spyke_attributes ||= ::Spyke::Attributes.new(scope.params)
-          use_setters(sanitize_for_mass_assignment(new_attributes)) if new_attributes && !new_attributes.empty?
+          @spyke_attributes ||= ::Spyke::Attributes.new(scope.params)
+          return unless new_attributes && !new_attributes.empty?
+          use_setters(sanitize_for_mass_assignment(new_attributes))
         end
 
         private
@@ -153,7 +145,7 @@ module FmRest
           mapped_attributes.values_at(*changed)
         end
 
-        # Use known mapped_attributes for inspect
+        # Spyke override (private) -- Use known mapped_attributes for inspect
         #
         def inspect_attributes
           mapped_attributes.except(primary_key).map do |k, v|

data/lib/fmrest/spyke/model/auth.rb

@@ -28,6 +28,14 @@ module FmRest
           rescue FmRest::V1::TokenSession::NoSessionTokenSet
             false
           end
+
+          def request_auth_token
+            FmRest::V1.request_auth_token(FmRest::V1.auth_connection(fmrest_config))
+          end
+
+          def request_auth_token!
+            FmRest::V1.request_auth_token!(FmRest::V1.auth_connection(fmrest_config))
+          end
         end
       end
     end

data/lib/fmrest/spyke/model/connection.rb

@@ -3,33 +3,112 @@
 module FmRest
   module Spyke
     module Model
+      # This module provides methods for configuring the Farday connection for
+      # the model, as well as setting up the connection itself.
+      #
       module Connection
-        extend ::ActiveSupport::Concern
+        extend ActiveSupport::Concern
 
         included do
-          class_attribute :fmrest_config, instance_accessor: false, instance_predicate: false
-
           class_attribute :faraday_block, instance_accessor: false, instance_predicate: false
           class << self; private :faraday_block, :faraday_block=; end
 
-          # FM Data API expects PATCH for updates (Spyke's default was PUT)
+          # FM Data API expects PATCH for updates (Spyke uses PUT by default)
           self.callback_methods = { create: :post, update: :patch }.freeze
         end
 
         class_methods do
+          def fmrest_config
+            if fmrest_config_overlay
+              return FmRest.default_connection_settings.merge(fmrest_config_overlay, skip_validation: true)
+            end
+
+            FmRest.default_connection_settings
+          end
+
+          # Sets the FileMaker connection settings for the model.
+          #
+          # Behaves similar to ActiveSupport's `class_attribute`, so it can be
+          # inherited and safely overwritten in subclasses.
+          #
+          # @param settings [Hash] The settings hash
+          #
+          def fmrest_config=(settings)
+            settings = ConnectionSettings.new(settings, skip_validation: true)
+
+            singleton_class.redefine_method(:fmrest_config) do
+              overlay = fmrest_config_overlay
+              return settings.merge(overlay, skip_validation: true) if overlay
+              settings
+            end
+          end
+
+          # Allows overriding some connection settings in a thread-local
+          # manner. Useful in the use case where you want to connect to the
+          # same database using different accounts (e.g. credentials provided
+          # by users in a web app context).
+          #
+          # @param (see #fmrest_config=)
+          #
+          def fmrest_config_overlay=(settings)
+            Thread.current[fmrest_config_overlay_key] = settings
+          end
+
+          # @return [FmRest::ConnectionSettings] the connection settings
+          #   overlay if any is in use
+          #
+          def fmrest_config_overlay
+            Thread.current[fmrest_config_overlay_key] || begin
+              superclass.fmrest_config_overlay
+            rescue NoMethodError
+              nil
+            end
+          end
+
+          # Clears the connection settings overlay.
+          #
+          def clear_fmrest_config_overlay
+            Thread.current[fmrest_config_overlay_key] = nil
+          end
+
+          # Runs a block of code in the context of the given connection
+          # settings without affecting the connection settings outside said
+          # block.
+          #
+          # @param (see #fmrest_config=)
+          #
+          # @example
+          #   Honeybee.with_overlay(username: "...", password: "...") do
+          #     Honeybee.query(...)
+          #   end
+          #
+          def with_overlay(settings, &block)
+            Fiber.new do
+              begin
+                self.fmrest_config_overlay = settings
+                yield
+              ensure
+                self.clear_fmrest_config_overlay
+              end
+            end.resume
+          end
+
+          # Spyke override -- Defaults to `fmrest_connection`
+          #
           def connection
             super || fmrest_connection
           end
 
           # Sets a block for injecting custom middleware into the Faraday
-          # connection. Example usage:
+          # connection.
           #
-          #     class MyModel < FmRest::Spyke::Base
-          #       faraday do |conn|
-          #         # Set up a custom logger for the model
-          #         conn.response :logger, MyApp.logger, bodies: true
-          #       end
+          # @example
+          #   class MyModel < FmRest::Spyke::Base
+          #     faraday do |conn|
+          #       # Set up a custom logger for the model
+          #       conn.response :logger, MyApp.logger, bodies: true
           #     end
+          #   end
           #
           def faraday(&block)
             self.faraday_block = block
@@ -38,26 +117,45 @@ module FmRest
           private
 
           def fmrest_connection
-            @fmrest_connection ||=
-              begin
-                config = fmrest_config || FmRest.default_connection_settings
+            memoize = false
+
+            # Don't memoize the connection if there's an overlay, since
+            # overlays are thread-local and so should be the connection
+            unless fmrest_config_overlay
+              return @fmrest_connection if @fmrest_connection
+              memoize = true
+            end
+
+            config = ConnectionSettings.wrap(fmrest_config)
 
-                FmRest::V1.build_connection(config) do |conn|
-                  faraday_block.call(conn) if faraday_block
+            connection =
+              FmRest::V1.build_connection(config) do |conn|
+                faraday_block.call(conn) if faraday_block
 
-                  # Pass the class to SpykeFormatter's initializer so it can have
-                  # access to extra context defined in the model, e.g. a portal
-                  # where name of the portal and the attributes prefix don't match
-                  # and need to be specified as options to `portal`
-                  conn.use FmRest::Spyke::SpykeFormatter, self
+                # Pass the class to SpykeFormatter's initializer so it can have
+                # access to extra context defined in the model, e.g. a portal
+                # where name of the portal and the attributes prefix don't match
+                # and need to be specified as options to `portal`
+                conn.use FmRest::Spyke::SpykeFormatter, self
 
-                  conn.use FmRest::V1::TypeCoercer, config
+                conn.use FmRest::V1::TypeCoercer, config
 
-                  # FmRest::Spyke::JsonParse expects symbol keys
-                  conn.response :json, parser_options: { symbolize_names: true }
-                end
+                # FmRest::Spyke::JsonParse expects symbol keys
+                conn.response :json, parser_options: { symbolize_names: true }
               end
+
+            @fmrest_connection = connection if memoize
+
+            connection
           end
+
+          def fmrest_config_overlay_key
+            :"#{object_id}.fmrest_config_overlay"
+          end
+        end
+
+        def fmrest_config
+          self.class.fmrest_config
         end
       end
     end

data/lib/fmrest/spyke/model/container_fields.rb

@@ -5,10 +5,25 @@ require "fmrest/spyke/container_field"
 module FmRest
   module Spyke
     module Model
+      # This module adds support for container fields.
+      #
       module ContainerFields
         extend ::ActiveSupport::Concern
 
         class_methods do
+          # Defines a container field on the model.
+          #
+          # @param name [Symbol] the name of the container field
+          #
+          # @option options [String] :field_name (nil) the name of the container
+          #   field in the FileMaker layout (only needed if it doesn't match
+          #   the name given)
+          #
+          # @example
+          #   class Honeybee < FmRest::Spyke::Base
+          #     container :photo, field_name: "Beehive Photo ID"
+          #   end
+          #
           def container(name, options = {})
             field_name = options[:field_name] || name
 

data/lib/fmrest/spyke/model/http.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fmrest/spyke/relation"
-
 module FmRest
   module Spyke
     module Model
@@ -15,6 +13,8 @@ module FmRest
           # execution results after a save, etc.
 
 
+          # Spyke override -- Keeps metadata in thread-local class variable.
+          #
           def request(*args)
             super.tap do |r|
               Thread.current[last_request_metadata_key] = r.metadata
@@ -32,6 +32,46 @@ module FmRest
           end
         end
       end
+
+      # Spyke override -- Uses `__record_id` for building the record URI.
+      #
+      def uri
+        ::Spyke::Path.new(@uri_template, fmrest_uri_attributes) if @uri_template
+      end
+
+      private
+
+      # Spyke override (private) -- Use `__record_id` instead of `id`
+      #
+      def resolve_path_from_action(action)
+        case action
+        when Symbol then uri.join(action)
+        when String then ::Spyke::Path.new(action, fmrest_uri_attributes)
+        else uri
+        end
+      end
+
+      def fmrest_uri_attributes
+        if persisted?
+          { __record_id: __record_id }
+        else
+          # NOTE: it seems silly to be calling attributes.slice(:__record_id)
+          # when the record is supposed to not have a record_id set (since
+          # persisted? is false here), but it makes sense in the context of how
+          # Spyke works:
+          #
+          # When calling Model.find(id), Spyke will internally create a scope
+          # with .where(primary_key => id) and call .find_one on it. Then,
+          # somewhere down the line Spyke creates a new empty instance of the
+          # current model class to get its .uri property (the one we're
+          # partially building through this method and which contains these URI
+          # attributes). When initializing a record Spyke first forcefully
+          # assigns the .where()-set attributes from the current scope onto
+          # that instance's attributes hash, which then leads us right here,
+          # where we might have __record_id assigned as a scope attribute:
+          attributes.slice(:__record_id)
+        end
+      end
     end
   end
 end