remote_record 0.7.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95e6b11dd488bf26b81544c37471498737a26598429ba8290e4e9c8e0f6d79a0
-  data.tar.gz: cb125226d35be488de6d72651bb1249539d4d2dec487f75e242fc949593b008c
+  metadata.gz: ffa98f2c80cd8bb5cf1c297a30e878a09a056daa139d8109a7179d9076c56f21
+  data.tar.gz: df9f87372e8ad4e348db5980acfd7912ed9cbd91fd4c06f18718627b58357c31
 SHA512:
-  metadata.gz: '08872bedccc7008cbf05129c2e9e791ee73c88bdc222dbaab1ff973bf32b0e24a284690072394c4b6e9a5126f7c0c851e6a2ffbf7ef855909397fbc77d870cbd'
-  data.tar.gz: d86cd65b6db39f4191d39b0be6e954b56b118daa02534eb0b8c20e10fcf988d9e07ada0fef2fc418e787b1a112dfc300b31df2f7afde199df88bb3fab68d04ca
+  metadata.gz: 9f522c6b252935a1340de6ea9ebdc6a8825610199a71ecbdfb6cbc4de9202167d34326b239bed5b80f14cca2353572a7af96d7f61a703d4dd746056ed6111e99
+  data.tar.gz: b5875964305b1cad3a96765f5e0e19714032d47c093701c63ededd93e9aaa7389c907fcfc4d7949588fa6f8a6a3103d7cfb5074714de1ddd18cb29d4b59a8d6a

data/README.md

@@ -1,4 +1,4 @@
-![RemoteRecord: Ready-made remote resource structures.](doc/header.svg)
+![Remote Record: Ready-made remote resource structures.](doc/header.svg)
 
 ---
 
@@ -9,12 +9,12 @@ Every API speaks a different language. Maybe it's REST, maybe it's SOAP, maybe
 it's GraphQL. Maybe it's got its own Ruby client, or maybe you need to roll your
 own. But what if you could just pretend it existed in your database?
 
-RemoteRecord provides a consistent ActiveRecord inspired interface for all of
-your application's APIs. Store remote resources by ID, and RemoteRecord will
-auto-populate instances of your ActiveRecord model with their attributes from
-the API. Whether you're dealing with a user on GitHub, a track on Spotify, a
-place on Google Maps, or a resource on your internal infrastructure, you can use
-RemoteRecord to wrap fetching it.
+Remote Record provides a consistent Active Record-inspired interface for all of
+your application's APIs. Store remote resources by ID, and Remote Record will
+let you access objects containing their attributes from the API. Whether you're
+dealing with a user on GitHub, a track on Spotify, a place on Google Maps, or a
+resource on your internal infrastructure, you can use Remote Record to wrap
+fetching it.
 
 ## Setup
 
@@ -31,7 +31,7 @@ remote resource. In this example, it's `RemoteRecord::GitHub::User`.
 
 ### Creating a remote record class
 
-A standard RemoteRecord class looks like this. It should have a `get` method,
+A standard Remote Record class looks like this. It should have a `get` method,
 which returns a hash of data you'd like to query on the user.
 
 `RemoteRecord::Base` exposes private methods for the `remote_resource_id` and
@@ -46,6 +46,8 @@ module RemoteRecord
         client.user(remote_resource_id)
       end
 
+      # Implement the Collection class here for fetching multiple records.
+
       private
 
       def client
@@ -56,10 +58,22 @@ module RemoteRecord
 end
 ```
 
+These classes can be used in isolation and don't directly depend on Active
+Record. You can use them outside of the context of Active Record or Rails:
+
+```ruby
+RemoteRecord::GitHub::User.new(1)
+=> <RemoteRecord::GitHub::User attrs={}>
+```
+
+If you call `fresh` or try to access an attribute, Remote Record will fetch the
+resource and put its data in this instance.
+
 ### Creating a remote reference
 
-To start using your remote record class, `include RemoteRecord` into your reference. Now, whenever
-you initialize an instance of your class, it'll be fetched.
+To start using your remote record class, `include RemoteRecord` into your
+reference. Now, whenever you initialize an instance of your class, it'll be
+fetched.
 
 Calling `remote_record` in addition to this lets you set some options:
 
@@ -69,7 +83,7 @@ Calling `remote_record` in addition to this lets you set some options:
 | id_field      | `:remote_resource_id`    | The field on the reference that contains the remote resource ID                                                                                                                    |
 | authorization | `''`                     | An object that can be used by the remote record class to authorize a request. This can be a value, or a proc that returns a value that can be used within the remote record class. |
 | memoize       | true                     | Whether reference instances should memoize the response that populates them                                                                                                        |
-| transform     | []                       | Whether the response should be put through a transformer (under RemoteRecord::Transformers). Currently, only `[:snake_case]` is available.                                         |
+| transform     | []                       | Whether the response should be put through a transformer (under `RemoteRecord::Transformers`). See `lib/remote_record/transformers` for options.                                   |
 
 ```ruby
 module GitHub
@@ -89,161 +103,142 @@ module GitHub
 end
 ```
 
-If your API doesn't require authentication at all, you don't even need to
-configure it. So at its best, RemoteRecord can be as lightweight as:
+If the default behavior suits you just fine, you don't even need to
+configure it. So at its best, Remote Record can be as lightweight as:
 
 ```ruby
 class JsonPlaceholderAPIReference < ApplicationRecord
   include RemoteRecord
-  # Falls back to the defaults, so it's equivalent to then calling:
-  # remote_record do |c|
-    # c.authorization proc { }
-    # c.id_field :remote_resource_id
-    # c.klass RemoteRecord::JsonPlaceholderAPI, # Inferred from module and class name
-    # c.memoize true
-    # c.transform []
-  # end
+  remote_record
 end
 ```
 
 ## Usage
 
-Now you've got everything lined up to start using your remote reference.
+Now you've got the basics lined up to start using your remote reference.
 
-Whenever a `GitHub::UserReference` is initialized, e.g. by calling:
+Whenever you call `remote` on a `GitHub::UserReference`:
 
 ```ruby
-user.github_user_references.first
+user.github_user_references.first.remote
 ```
 
-...it'll be populated with the GitHub user's data. You can call methods that
-return attributes on the user, like `#login` or `#html_url`.
+...you'll be able to use the GitHub user's data on an instance of
+`RemoteRecord::GitHub::User`. You can call methods that return attributes on the
+user, like `#login` or `#html_url`.
+
+For services that manage caching by way of expiry or ETags, I recommend using
+`faraday-http-cache` for your clients and setting `memoize` to `false`. Remote
+Record may eventually gain native support for caching your records to the
+database.
 
-By default, this'll only make a request on initialize. For services that manage
-caching by way of expiry or ETags, I recommend using `faraday-http-cache` for
-your clients and setting `memoize` to `false`. Remote Record will eventually
-gain support for caching.
+### `remote` scopes
 
-### `remote_all` and `remote_where`
+Remote Record also provides extensions to Active Record scopes. You can call
+`remote` on a scope to fetch all the remote resources at once. By default, this
+will use a single request per resource, which isn't often optimal.
 
-If you're able to fetch multiple records at once from the API, implement the
-`self.all` method on your remote record class. This should return an array of
-hashes that can be used to initialize a set of references.
+Implement the `Collection` class under your remote record class to fetch
+multiple records from the API in fewer requests. `all` should return an array
+of references.
 
-This can optionally take a block
-for authorization - note that it won't use the auth you've configured and that
-you'll always have to supply that inline. For example:
+Inheriting from `RemoteRecord::Collection` grants you some convenience methods
+you can use to pair the remote resources from the response with your existing
+references. Check out the class file under `lib/remote_record` for more details.
 
 ```ruby
 module RemoteRecord
   module GitHub
     # :nodoc:
     class User < RemoteRecord::Base
-      def get
-        client.user(remote_resource_id)
-      end
-
-      def self.all
-        Octokit::Client.new(access_token: yield).users
-      end
-
-      private
-
-      def client
-        Octokit::Client.new(access_token: authorization)
+      # ...
+      class Collection < RemoteRecord::Collection
+        def all
+          response = client.all_users
+          match_remote_resources_by_id(response)
+        end
+
+        private
+
+        def client
+          Octokit::Client.new
+        end
       end
     end
   end
 end
 ```
 
-Now you can call `remote_all` on remote reference classes that use
-`RemoteRecord::GitHub::User`, like this:
+Now you're ready to fetch all your resources at once:
 
 ```ruby
-GitHub::UserReference.remote_all { GITHUB_PERSONAL_ACCESS_TOKEN }
+GitHub::UserReference.remote.all
 ```
 
-`remote_where` works in the same way, but with a parameter:
+`remote.where` works in the same way, but with a parameter:
 
 ```ruby
 module RemoteRecord
   module GitHub
     # :nodoc:
     class User < RemoteRecord::Base
-      def get
-        client.user(remote_resource_id)
-      end
-
-      def self.all
-        Octokit::Client.new(access_token: yield).users
-      end
-
-      def self.where(query)
-        Octokit::Client.new(access_token: yield).search_users(query)
-      end
-
-      private
-
-      def client
-        Octokit::Client.new(access_token: authorization)
+      # ...
+      class Collection < RemoteRecord::Collection
+        def all
+          response = client.all_users
+          match_remote_resources_by_id(response)
+        end
+
+        def where(query)
+          response = client.search_users(query)
+          match_remote_resources_by_id(response)
+        end
+
+        private
+
+        def client
+          Octokit::Client.new
+        end
       end
     end
   end
 end
 ```
 
-Now you can call `remote_where` on remote reference classes that use
+Now you can call `remote.where` on remote reference classes that use
 `RemoteRecord::GitHub::User`, like this:
 
 ```ruby
-GitHub::UserReference.remote_where('q=tom+repos:%3E42+followers:%3E1000') { GITHUB_PERSONAL_ACCESS_TOKEN }
+GitHub::UserReference.remote.where('q=tom+repos:%3E42+followers:%3E1000')
 ```
 
-It's recommended that you include something in `self.where` to filter incoming
+*Note that the query we're expecting here comes from the Octokit gem. Your API
+client might have a nicer interface.*
+
+It's recommended that you include something in `where` to filter incoming
 params. Ideally, you want to expose an interface that's as ActiveRecord-like as
 possible, e.g.:
 
 ```ruby
-GitHub::UserReference.remote_where(q: 'tom', repos: '>42', followers: '>1000') { GITHUB_PERSONAL_ACCESS_TOKEN }
+GitHub::UserReference.remote_where(q: 'tom', repos: '>42', followers: '>1000')
 ```
 
-It's recommended that you write a `Transformer` to do this. Check out
-`RemoteRecord::Transformers::SnakeCase` for an example.
+You can use or write a `Transformer` to do this. Check out the
+`RemoteRecord::Transformers` module for examples.
 
 ### `initial_attrs`
 
-Behind the scenes, `remote_all` initializes references with a set of
-`initial_attrs`. You can do the same! If you've already fetched the data for an
-object, just pass it to `new` for your reference class under the
-`initial_attrs:`  keyword parameter, like this:
+Behind the scenes, `match_remote_resources` sets the remote instance's `attrs`.
+You can do the same! If you've already fetched the data for an object, set it
+via `attrs`, like this:
 
 ```ruby
 todo = { id: 1, title: 'Hello world' }
-TodoReference.new(remote_resource_id: todo[:id], initial_attrs: todo)
+todo_reference = TodoReference.new(remote_resource_id: todo[:id])
+todo_reference.remote.attrs = todo
 ```
 
 ### Forcing a fresh request
 
-You might want to force a fresh request in some instances, even if you're using
-`memoize`. To do this, call `fresh` on a reference, and it'll be repopulated.
-
-### Skip fetching
-
-You might not want to make a request on initialize sometimes. In this case, pass
-`fetching: false` when creating or initializing references to make sure the
-resource isn't fetched.
-
-When querying for records using ActiveRecord alone, you might want to do so
-within a `no_fetching` context:
-
-```ruby
-TodoReference.no_fetching { |model| model.where(remote_resource_id: 1) }
-```
-
-Any records initialized within a `no_fetching` context won't be requested. It's
-sort of like a `Faraday` cage, pun entirely intended.
-
-If you're using `remote_all` or `remote_where` to fetch using your API, that'll
-automatically use this behind the scenes, then set `attrs` to the response
-value.
+You might want to force a fresh request in some instances. To do this, call
+`fresh` on a reference, and it'll be repopulated.

data/lib/remote_record.rb

@@ -2,8 +2,11 @@
 
 require 'active_support/concern'
 require 'active_support/rescuable'
+require 'active_record/type'
+require 'remote_record/type'
 require 'remote_record/base'
 require 'remote_record/class_lookup'
+require 'remote_record/collection'
 require 'remote_record/config'
 require 'remote_record/dsl'
 require 'remote_record/reference'

data/lib/remote_record/base.rb

@@ -5,17 +5,27 @@ module RemoteRecord
   class Base
     include ActiveSupport::Rescuable
 
-    def self.default_config
-      Config.defaults.merge(remote_record_class: self)
+    # When you inherit from `Base`, it'll set up an Active Record Type for you
+    # available on its Type constant. It'll also have a Collection.
+    def self.inherited(subclass)
+      subclass.const_set :Type, RemoteRecord::Type.for(subclass)
+      subclass.const_set :Collection, Class.new(RemoteRecord::Collection) unless subclass.const_defined? :Collection
+      super
     end
+    attr_reader :remote_resource_id
+    attr_accessor :remote_record_config
 
-    def initialize(reference, options = default_config, initial_attrs = {})
-      @reference = reference
-      @options = options
+    def initialize(remote_resource_id,
+                   remote_record_config = Config.defaults,
+                   initial_attrs = {})
+      @remote_resource_id = remote_resource_id
+      @remote_record_config = remote_record_config
       @attrs = HashWithIndifferentAccess.new(initial_attrs)
+      @fetched = initial_attrs.present?
     end
 
     def method_missing(method_name, *_args, &_block)
+      fetch unless @remote_record_config.memoize && @fetched
       transform(@attrs).fetch(method_name)
     rescue KeyError
       super
@@ -29,25 +39,25 @@ module RemoteRecord
       raise NotImplementedError.new, '#get should return a hash of data that represents the remote record.'
     end
 
-    def self.all
-      raise NotImplementedError.new, '#all should return an array of hashes of data that represent remote records.'
-    end
-
-    def self.where(_params)
-      raise NotImplementedError.new, '#where should return an array of hashes of data that represent remote records.'
-    end
-
     def fetch
       @attrs.update(get)
+      @fetched = true
     end
 
     def attrs=(new_attrs)
       @attrs.update(new_attrs)
     end
 
+    def fresh
+      fetch
+      self
+    end
+
     private
 
     def transform(data)
+      return data unless transformers.any?
+
       transformers.reduce(data) do |transformed_data, transformer|
         transformer.new(transformed_data).transform
       end
@@ -55,18 +65,14 @@ module RemoteRecord
 
     # Robots in disguise.
     def transformers
-      @options.transform.map do |transformer_name|
+      @remote_record_config.transform.map do |transformer_name|
         "RemoteRecord::Transformers::#{transformer_name.to_s.camelize}".constantize
       end
     end
 
     def authorization
-      authz = @options.authorization
-      authz.respond_to?(:call) ? authz.call(@reference, @options) : authz
-    end
-
-    def remote_resource_id
-      @reference.send(@options.id_field)
+      authz = @remote_record_config.authorization
+      authz.respond_to?(:call) ? authz.call(@remote_record_config.authorization_source) : authz
     end
   end
 end

data/lib/remote_record/collection.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RemoteRecord
+  # Wraps operations on collections of remote references. By calling #remote on
+  # on an ActiveRecord relation, you'll get a RemoteRecord::Collection you can
+  # use to more easily fetch multiple records at once.
+  #
+  # The default implementation is naive and sends a request per object.
+  class Collection
+    delegate :length, to: :@relation
+
+    def initialize(active_record_relation, config = nil, id: :remote_resource_id)
+      @relation = active_record_relation
+      @config = config
+      @id_field = id
+    end
+
+    def all
+      fetch_all_scoped_records(@relation)
+    end
+
+    def where
+      raise NotImplementedError.new,
+            "Implement #where on #{self.class.name} to filter records using the API."
+    end
+
+    private
+
+    # Override this to define more succinct ways to request all records at once.
+    # If your API has a search endpoint, you may want to use that. Otherwise,
+    # list all objects and leave it to Remote Record to pick out the ones you
+    # have in your database.
+    def fetch_all_scoped_records(relation)
+      relation.map do |record|
+        record.remote.remote_record_config.merge!(@config)
+        record.tap { |r| r.remote.fresh }
+      end
+    end
+
+    def match_remote_resources(response)
+      @relation.map do |record|
+        prefetched_record = response.find do |resource|
+          yield(resource).to_s == record.public_send(@id_field).remote_resource_id
+        end
+        record.remote.attrs = prefetched_record if prefetched_record.present?
+        record
+      end
+    end
+
+    def match_remote_resources_by_id(response)
+      match_remote_resources(response) { |resource| resource['id'] }
+    end
+  end
+end

data/lib/remote_record/config.rb

@@ -7,7 +7,7 @@ module RemoteRecord
   # defaults of the remote record class and the overrides set when
   # `remote_record` is called.
   class Config
-    OPTIONS = %i[remote_record_class authorization memoize id_field transform].freeze
+    OPTIONS = %i[authorization authorization_source memoize id_field transform].freeze
 
     def initialize(**options)
       @options = options
@@ -16,6 +16,7 @@ module RemoteRecord
     def self.defaults
       new(
         authorization: '',
+        authorization_source: nil,
         memoize: true,
         id_field: :remote_resource_id,
         transform: []
@@ -41,9 +42,19 @@ module RemoteRecord
       @options
     end
 
-    def merge(**overrides)
+    def merge(config = nil, **overrides)
+      @options.yield_self { |options| options.merge(**(config || {}).to_h) }
+              .yield_self { |options| options.merge(**overrides) }
+    end
+
+    def merge!(config = nil, **overrides)
+      @options.merge!(**config.to_h) if config.present?
       @options.merge!(**overrides)
       self
     end
+
+    def ==(other)
+      other.to_h == @options
+    end
   end
 end

data/lib/remote_record/dsl.rb

@@ -8,12 +8,16 @@ module RemoteRecord
   module DSL
     extend ActiveSupport::Concern
     class_methods do
-      def remote_record(remote_record_class: nil)
-        klass = RemoteRecord::ClassLookup.new(self).remote_record_class(remote_record_class)
-        config = RemoteRecord::Config.new(remote_record_class: klass)
-        config = yield(config) if block_given?
-        DSLPrivate.validate_config(config)
-        define_singleton_method(:remote_record_config) { config }
+      def remote_record(remote_record_class: nil, field: :remote_resource_id)
+        klass = DSLPrivate.lookup_and_validate_class(self, remote_record_class)
+        base_config = RemoteRecord::Config.defaults
+        base_config = yield(base_config) if block_given?
+        # Register the field as an Active Record attribute of the remote record
+        # class's type
+        attribute field, klass::Type[base_config].new
+
+        DSLPrivate.define_remote_scope(self, klass, field)
+        DSLPrivate.define_remote_accessor(self, field)
       end
     end
   end
@@ -21,15 +25,40 @@ module RemoteRecord
   # Methods private to the DSL module.
   module DSLPrivate
     class << self
-      def responds_to_get?(klass)
-        klass.instance_methods(false).include? :get
+      def lookup_and_validate_class(klass, override)
+        RemoteRecord::ClassLookup.new(klass).remote_record_class(override).tap do |found_klass|
+          validate_responds_to_get(found_klass)
+        end
       end
 
-      def validate_config(config)
-        klass = RemoteRecord::ClassLookup.new(self.class.to_s)
-                                         .remote_record_class(config.to_h[:remote_record_class].to_s)
+      # Define the #remote scope, which returns a Collection for the given
+      # Remote Record class
+      def define_remote_scope(base, klass, field_name)
+        return if base.respond_to?(:remote)
+
+        base.define_singleton_method(:remote) do |id_field = field_name, config: nil|
+          klass::Collection.new(all, config, id: id_field)
+        end
+      end
+
+      # Define the #remote accessor for instances - this uses the Active
+      # Record type, but adds a reference to the parent object into the config
+      # to be used in authorization.
+      def define_remote_accessor(base, field_name)
+        return if base.instance_methods(false).include?(:remote)
+
+        base.define_method(:remote) do |id_field = field_name|
+          self[id_field].tap { |record| record.remote_record_config.merge!(authorization_source: self) }
+        end
+      end
+
+      def validate_responds_to_get(klass)
         raise NotImplementedError.new, 'The remote record does not implement #get.' unless responds_to_get?(klass)
       end
+
+      def responds_to_get?(klass)
+        klass.instance_methods(false).include? :get
+      end
     end
   end
 end

data/lib/remote_record/reference.rb

@@ -9,131 +9,8 @@ module RemoteRecord
   module Reference
     extend ActiveSupport::Concern
 
-    class_methods do # rubocop:disable Metrics/BlockLength
-      attr_accessor :fetching
-
-      def remote_record_class
-        ClassLookup.new(self).remote_record_class(
-          remote_record_config.to_h[:remote_record_class]&.to_s
-        )
-      end
-
-      # Default to an empty config, which falls back to the remote record
-      # class's default config and leaves the remote record class to be inferred
-      # from the reference class name
-      # This method is overridden using RemoteRecord::DSL#remote_record.
-      def remote_record_config
-        Config.new
-      end
-
-      def fetching
-        @fetching = true if @fetching.nil?
-        @fetching
-      end
-
-      # Disable fetching for all records initialized in the block.
-      def no_fetching
-        self.fetching = false
-        block_return_value = yield(self)
-        self.fetching = true
-        block_return_value
-      end
-
-      def remote_all(&authz_proc)
-        find_or_initialize_all(remote_record_class.all(&authz_proc))
-      end
-
-      def remote_where(params, &authz_proc)
-        find_or_initialize_all(remote_record_class.where(params, &authz_proc))
-      end
-
-      private
-
-      def find_or_initialize_all(remote_resources)
-        no_fetching do
-          pair_remote_resources_with_records(remote_resources) do |unsaved_resources, relation|
-            new_resources = unsaved_resources.map do |resource|
-              new(remote_resource_id: resource['id']).tap { |record| record.attrs = resource }
-            end
-            relation.to_a + new_resources
-          end
-        end
-      end
-
-      def pair_remote_resources_with_records(remote_resources)
-        # get resource ids
-        ids = remote_resource_ids(remote_resources)
-        # get what exists in the database
-        relation = where(remote_resource_id: ids)
-        # for each record, set its attrs
-        relation.map do |record|
-          record.attrs = remote_resources.find do |r|
-            r['id'].to_s == record.remote_resource_id.to_s
-          end
-        end
-        unsaved_resources = resources_without_persisted_references(remote_resources, relation)
-        yield(unsaved_resources, relation)
-      end
-
-      def remote_resource_ids(remote_resources)
-        remote_resources.map { |remote_resource| remote_resource['id'] }
-      end
-
-      def resources_without_persisted_references(remote_resources, relation)
-        remote_resources.reject do |resource|
-          relation.pluck(:remote_resource_id).include? resource['id']
-        end
-      end
-    end
-
-    # rubocop:disable Metrics/BlockLength
     included do
       include ActiveSupport::Rescuable
-      attribute :fetching, :boolean, default: -> { fetching }
-      attr_accessor :initial_attrs
-
-      after_initialize do |reference|
-        reference.fetching = false if reference.initial_attrs.present?
-        config = reference.class.remote_record_class.default_config.merge(
-          reference.class.remote_record_config.to_h
-        )
-        reference.instance_variable_set('@remote_record_config', config)
-        reference.instance_variable_set('@instance',
-                                        @remote_record_config.remote_record_class.new(
-                                          self, @remote_record_config, reference.initial_attrs.presence || {}
-                                        ))
-        reference.fetch_remote_resource
-      end
-
-      # This doesn't call `super` because it delegates to @instance in all
-      # cases.
-      def method_missing(method_name, *_args, &_block)
-        fetch_remote_resource unless @remote_record_config.memoize
-
-        instance.public_send(method_name)
-      end
-
-      def respond_to_missing?(method_name, _include_private = false)
-        instance.respond_to?(method_name, false)
-      end
-
-      def fetch_remote_resource
-        instance.fetch if fetching
-      rescue Exception => e # rubocop:disable Lint/RescueException
-        rescue_with_handler(e) || raise
-      end
-
-      def fresh
-        instance.fetch
-        self
-      end
-
-      delegate :attrs=, to: :@instance
-
-      def instance
-        @instance ||= @remote_record_config.remote_record_class.new(self, @remote_record_config)
-      end
     end
-    # rubocop:enable Metrics/BlockLength
   end
 end

data/lib/remote_record/type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative './config'
+
+module RemoteRecord
+  # RemoteRecord uses the Active Record Types system to serialize to and from a
+  # remote resource.
+  class Type < ActiveRecord::Type::Value
+    class_attribute :config, default: RemoteRecord::Config.defaults, instance_writer: false, instance_predicate: false
+    class_attribute :parent, instance_writer: false, instance_predicate: false
+
+    def type
+      :string
+    end
+
+    def cast(_remote_resource_id)
+      raise 'cast not defined'
+    end
+
+    def deserialize(value)
+      cast(value)
+    end
+
+    def serialize(representation)
+      return representation.remote_resource_id if representation.respond_to? :remote_resource_id
+
+      representation.to_s
+    end
+
+    def self.for(remote_record_class)
+      Class.new(self) do |type|
+        type.parent = remote_record_class
+        def self.[](config_override)
+          Class.new(self).tap { |configured_type| configured_type.config = config_override }
+        end
+
+        def cast(remote_resource_id)
+          return remote_resource_id if remote_resource_id.is_a?(parent)
+
+          parent.new(remote_resource_id, config)
+        end
+      end
+    end
+  end
+end

data/lib/remote_record/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RemoteRecord
-  VERSION = '0.7.1'
+  VERSION = '0.9.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remote_record
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Simon Fish
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-11 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -178,12 +178,14 @@ files:
 - lib/remote_record.rb
 - lib/remote_record/base.rb
 - lib/remote_record/class_lookup.rb
+- lib/remote_record/collection.rb
 - lib/remote_record/config.rb
 - lib/remote_record/dsl.rb
 - lib/remote_record/reference.rb
 - lib/remote_record/transformers.rb
 - lib/remote_record/transformers/base.rb
 - lib/remote_record/transformers/snake_case.rb
+- lib/remote_record/type.rb
 - lib/remote_record/version.rb
 homepage: https://github.com/raisedevs/remote_record
 licenses:
@@ -206,7 +208,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Ready-made remote resource structures.