remote_record 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bf471bd03525a3f6dfdfedc1d88e2681264c85e98447607259fec7a94d56ddd
-  data.tar.gz: 076113352a325ee80c09cca58a00cdd8e703a584392319f008393fdae90ddbc2
+  metadata.gz: 8b0ea2bc5ed71919334a2a22d53f70a38ad06b116c7e76679e76bb0aeeb9ec9c
+  data.tar.gz: 4874762ea7e61fc354e99faa8d4cf6e79ba9b1451dcf5eefb029e2c173911b13
 SHA512:
-  metadata.gz: 3dc11719e885adf6220ef9b351b1605943ce25220c3e95ee0ee8820175685783777ed7f1bd43f22249f83cb95e8031509e2b85f8be04b65dc33aaab0c4fdca22
-  data.tar.gz: 478180ddc5b281c7a9873313608ad62368f9c947125fd1095b1c61a88e9cce5147637ca1391c801a0af1c2f53e4ac34418256a38563893f926a4f55ee37d62b4
+  metadata.gz: 603cbf7ecd366f2e3ba00c0be7d1ef793a484948a4940ddae511ab7e99583620d405cee4068958099dcf44aec52bdcc0df612771fc9b9243db530b643d5f1220
+  data.tar.gz: d5edee74efd6afd30db89d237674c5deb6953279636accc3e22b28b95e866f769631dc4a13fa70b30982e8f1422f2707bd9ccac2b0b1bdca2de5824e21e9c732

data/README.md

@@ -124,6 +124,105 @@ 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_all` and `remote_where`
+
+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.
+
+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:
+
+```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)
+      end
+    end
+  end
+end
+```
+
+Now you can call `remote_all` on remote reference classes that use
+`RemoteRecord::GitHub::User`, like this:
+
+```ruby
+GitHub::UserReference.remote_all { GITHUB_PERSONAL_ACCESS_TOKEN }
+```
+
+`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)
+      end
+    end
+  end
+end
+```
+
+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 }
+```
+
+It's recommended that you include something in `self.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 }
+```
+
+It's recommended that you write a `Transformer` to do this. Check out
+`RemoteRecord::Transformers::SnakeCase` for an example.
+
+### `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:
+
+```ruby
+todo = { id: 1, title: 'Hello world' }
+TodoReference.new(remote_resource_id: todo[:id], initial_attrs: todo)
+```
+
 ### Forcing a fresh request
 
 You might want to force a fresh request in some instances, even if you're using
@@ -131,4 +230,6 @@ You might want to force a fresh request in some instances, even if you're using
 
 ### Skip fetching
 
-You might not want to make a request on initialize sometimes. In this case, pass `fetching: false` to your query or `new` to make sure the resource isn't fetched.
+You might not want to make a request on initialize sometimes. In this case, pass
+`fetching: false` to your query or `new` to make sure the resource isn't
+fetched.

data/lib/remote_record/base.rb

@@ -9,10 +9,10 @@ module RemoteRecord
       Config.defaults.merge(remote_record_class: self)
     end
 
-    def initialize(reference, options)
+    def initialize(reference, options = default_config, initial_attrs = {})
       @reference = reference
-      @options = options.presence || default_config
-      @attrs = HashWithIndifferentAccess.new
+      @options = options
+      @attrs = HashWithIndifferentAccess.new(initial_attrs)
     end
 
     def method_missing(method_name, *_args, &_block)
@@ -29,6 +29,14 @@ 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)
     end

data/lib/remote_record/reference.rb

@@ -23,19 +23,37 @@ module RemoteRecord
       def remote_record_config
         Config.new
       end
+
+      def remote_all(&authz_proc)
+        remote_record_class.all(&authz_proc).map do |remote_resource|
+          where(remote_resource_id: remote_resource['id']).first_or_initialize(initial_attrs: remote_resource)
+        end
+      end
+
+      def remote_where(params, &authz_proc)
+        remote_record_class.where(params, &authz_proc).map do |remote_resource|
+          where(remote_resource_id: remote_resource['id']).first_or_initialize(initial_attrs: remote_resource)
+        end
+      end
     end
 
     # rubocop:disable Metrics/BlockLength
     included do
       include ActiveSupport::Rescuable
       attr_accessor :fetching
+      attr_accessor :initial_attrs
 
       after_initialize do |reference|
         reference.fetching = true if reference.fetching.nil?
+        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
 

data/lib/remote_record/transformers/base.rb

@@ -4,8 +4,11 @@ module RemoteRecord
   module Transformers
     # Base transformer class. Inherit from this and implement `#transform`.
     class Base
-      def initialize(data)
+      def initialize(data, direction = :up)
+        raise ArgumentError, 'The direction should be one of :up or :down.' unless %i[up down].include? direction
+
         @data = data
+        @direction = direction
       end
 
       def transform

data/lib/remote_record/transformers/snake_case.rb

@@ -15,14 +15,19 @@ module RemoteRecord
         when Array
           value.map { |v| convert_hash_keys(v) }
         when Hash
-          Hash[value.map { |k, v| [underscore_key(k), convert_hash_keys(v)] }]
+          Hash[value.map { |k, v| [transform_key(k), convert_hash_keys(v)] }]
         else
           value
         end
       end
 
-      def underscore_key(key)
-        key.to_s.underscore.to_sym
+      def transform_key(key)
+        case @direction
+        when :up
+          key.to_s.underscore.to_sym
+        when :down
+          key.to_s.camelize(:lower).to_sym
+        end
       end
     end
   end

data/lib/remote_record/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remote_record
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Simon Fish
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-12 00:00:00.000000000 Z
+date: 2021-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,20 +39,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: database_cleaner
-  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: faraday
   requirement: !ruby/object:Gem::Requirement