dynamoid 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eac484a25ff6886d838773be1b34f1fa9c7a51bf75ec46ed93984e97f273575c
-  data.tar.gz: 349e23120b78776d352c576bd7ffe0d2d1a2b69b0b5107d81698435bcbe2fb2e
+  metadata.gz: 7dd36d27f502c400c3275bf584ce8eba095b32732db1b9567ad9a3ceac64eb50
+  data.tar.gz: '084f10baa66c9d22febfaa884f410be5222774283d58fda3f237c7b9b204c572'
 SHA512:
-  metadata.gz: cdbe5b559ceea1a834c6bfdbd956bc0dcba57172be55a4003213dafdd54e702b8ae7c1f62f6a04c11f13f3f3907429cbff1e008ccfcef2b90e54b512c301b38f
-  data.tar.gz: 796c4496a3cabdde4433ee18797176d674e8be5ca887978d73792bea7fdf8cc0e697ca475c5b50cc972217524a6a006751f7497c84dbbe40a0a296bad5b1a79d
+  metadata.gz: 43ac82ed7d651e4b92845bf08f372ca57bf7b3bde0c3f49a3afbc7b6cbd1125574938472d6041627882e82c90379e5063ecd285d0092761cb4a5c209f9041510
+  data.tar.gz: 2a7f71ed8470bfce21a0b1c761d99681f02bbd797be65b2a4fe21ea72c54b7c22e52571f43ddcbedf980ab24ac26a4b54df1c41fd464f2cc1bdd7ac10817df33

data/CHANGELOG.md

@@ -12,6 +12,29 @@
 
 
 
+# 3.4.0
+
+## Features
+* Feature: [#386](https://github.com/Dynamoid/dynamoid/pull/386) Disable timestamps fields on a table level with new
+  table option `timestamps`
+* Feature: [#387](https://github.com/Dynamoid/dynamoid/pull/387) Add TTL support with table option `expires`
+* Feature: [#393](https://github.com/Dynamoid/dynamoid/pull/393) Support pre-configured credentials with new config
+  option `credentials` (@emmajhyde)
+* Feature: [#397](https://github.com/Dynamoid/dynamoid/pull/397) Configure on-demand table capacity mode with `capacity_mode` option
+
+## Improvements
+* Improvement: [#388](https://github.com/Dynamoid/dynamoid/pull/388) Minor memory optimization - don't allocate excessive
+  hash (@arjes)
+
+## Fixes
+
+Fix: [#382](https://github.com/Dynamoid/dynamoid/pull/382) Fixed deprecation warning about `Module#parent_name` in Rails 6 (@tmandke)
+Fix: Typos in Readme.md (@romeuhcf)
+
+---
+
+
+
 # 3.3.0
 
 ## Features

data/README.md

@@ -34,7 +34,7 @@ Gemfile:
 ```ruby
 gem 'dynamoid'
 ```
-## Prerequisities
+## Prerequisites
 
 Dynamoid depends on the aws-sdk, and this is tested on the current
 version of aws-sdk (~> 3), rails (>= 4). Hence the configuration as
@@ -80,6 +80,27 @@ Dynamoid.configure do |config|
 end
 ```
 
+Additionally, if you would like to pass in pre-configured AWS credentials
+(e.g. you have an IAM role credential, you configure your credentials
+elsewhere in your project, etc.), you may do so:
+
+```ruby
+require 'dynamoid'
+
+credentials = Aws::AssumeRoleCredentials.new(
+    region: region,
+    access_key_id: key,
+    secret_access_key: secret,
+    role_arn: role_arn,
+    role_session_name: 'our-session'
+  )
+
+Dynamoid.configure do |config|
+  config.region = 'us-west-2',
+  config.credentials = credentials
+end
+```
+
 For a full list of the DDB regions, you can go
 [here](http://docs.aws.amazon.com/general/latest/gr/rande.html#ddb_region).
 
@@ -143,6 +164,47 @@ won't change its hash key, which it expects will be `user_id`. If this
 table doesn't exist yet, however, Dynamoid will create it with these
 options.
 
+There is a basic support of DynamoDB's [Time To Live (TTL)
+mechanism](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html).
+If you declare a field as TTL field - it will be initialised if doesn't
+have value yet. Default value is current time + specified seconds.
+
+```ruby
+class User
+  include Dynamoid::Document
+
+  table expires: { field: :ttl, after: 60 }
+
+  field :ttl, :integer
+end
+```
+
+Field used to store expiration time (e.g. `ttl`) should be declared
+explicitly and should have numeric type (`integer`, `number`) only.
+`datetime` type is also possible but only if it's stored as number
+(there is a way to store time as a string also).
+
+It's also possible to override a global option `Dynamoid::Config.timestamps`
+on a table level:
+
+```ruby
+table timestamps: false
+```
+
+This option controls generation of timestamp fields
+`created_at`/`updated_at`.
+
+It's also possible to override table capacity mode configured globally
+with table level option `capacity_mode`. Valid values are
+`:provisioned`, `:on_demand` and `nil`:
+
+```ruby
+table capacity_mode: :on_demand
+```
+
+If table capacity mode is on-demand, another related table-level options
+`read_capacity` and `write_capacity` will be ignored.
+
 ### Fields
 
 You'll have to define all the fields on the model and the data type of
@@ -165,8 +227,8 @@ backward-compatibility of the serialized representation.
 
 The boolean fields are stored as DynamoDB boolean values by default.
 Dynamoid can store boolean values as strings as well - `'t'` and `'f'`.
-So if you want to change default format of boolean field you can easily
-achieve this with `store_as_native_boolean` field option:
+So if you want to change the default format of boolean field you can
+easily achieve this with `store_as_native_boolean` field option:
 
 ```ruby
 class Document
@@ -513,7 +575,7 @@ c.my_new_type
 
 ### Type casting
 
-Dynamid supports type casting and tryes to do it in the most convinient
+Dynamid supports type casting and tries to do it in the most convenient
 way. Values for all fields (except custom type) are coerced to declared
 field types.
 
@@ -551,7 +613,7 @@ well.
 
 ### Dirty API
 
-Dynamoid supports Dirty API which equvalents to [Rails 5.2
+Dynamoid supports Dirty API which equivalents to [Rails 5.2
 `ActiveModel::Dirty`](https://api.rubyonrails.org/v5.2/classes/ActiveModel/Dirty.html).
 There is only one limitation - change in place of field isn't detected
 automatically.
@@ -624,7 +686,7 @@ to relational database engines.
 
 **WARNING:** There is a limitation of conditions passed to `where`
 method. Only one condition for some particular field could be specified.
-The last one only will be applyed and others will be ignored. E.g. in
+The last one only will be applied and others will be ignored. E.g. in
 examples:
 
 ```ruby
@@ -714,7 +776,7 @@ commands.
 At times it can be useful to rely on DynamoDB [low-level
 pagination](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination)
 instead of fixed pages sizes. Each page results in a single Query or
-Scan call to DyanmoDB, but returns an unknown number of records.
+Scan call to DynamoDB, but returns an unknown number of records.
 
 Access to the native DynamoDB pages can be obtained via the
 `find_by_pages` method, which yields arrays of records.
@@ -729,7 +791,7 @@ is a hash including a key `:last_evaluated_key`. The value of this key
 can be used for the `start` method to fetch the next page of records.
 
 This way it can be used for instance to implement efficiently pagination
-in web-application:
+in web-applications:
 
 ```ruby
 class UserController < ApplicationController
@@ -774,7 +836,7 @@ Address.where('postcode.null': false)
 Address.where('postcode.not_null': true)
 ```
 
-**WARNING:** Please take into accout that `NULL` and `NOT_NULL`
+**WARNING:** Please take into account that `NULL` and `NOT_NULL`
 operators check attribute presence in a document, not value. So if
 attribute `postcode`'s value is `NULL`, `NULL` operator will return
 false because attribute exists even if has `NULL` value.
@@ -831,7 +893,7 @@ User.where("created_at.lt": DateTime.now - 1.day).all
 
 It also supports `gte` and `lte`. Turning those into symbols and
 allowing a Rails SQL-style string syntax is in the works. You can only
-have one range argument per query, because of DynamoDB's inherent
+have one range argument per query, because of DynamoDB inherent
 limitations, so use it sensibly!
 
 
@@ -839,7 +901,7 @@ limitations, so use it sensibly!
 
 In order to update document you can use high level methods
 `#update_attributes`, `#update_attribute` and `.update`. They run
-validation and collbacks.
+validation and callbacks.
 
 ```ruby
 Address.find(id).update_attributes(city: 'Chicago')
@@ -855,12 +917,12 @@ it runs `update` callbacks). All of them support conditional updates.
 doesn't exist.
 
 ```ruby
-Adderess.find(id).update do |i|
+Address.find(id).update do |i|
   i.set city: 'Chicago'
   i.add latitude: 100
   i.delete set_of_numbers: 10
 end
-Adderess.find(id).update(if: { deliverable: true }) do |i|
+Address.find(id).update(if: { deliverable: true }) do |i|
   i.set city: 'Chicago'
 end
 Address.update_fields(id, city: 'Chicago')
@@ -872,7 +934,7 @@ Address.upsert(id, { city: 'Chicago' }, if: { deliverable: true })
 ### Deleting
 
 In order to delete some items `delete_all` method should be used. Any
-callback wont be called. Items delete in efficient way in batch.
+callback won't be called. Items delete in efficient way in batch.
 
 ```ruby
 Address.where(city: 'London').delete_all
@@ -893,17 +955,17 @@ class User
 end
 ```
 
-There are following options:
+There are the following options:
 * `hash_key` - is used as hash key of an index,
 * `range_key` - is used as range key of an index,
 * `projected_attributes` - list of fields to store in an index or has a
-  predefiled value `:keys_only`, `:all`; `:keys_only` is a default,
+  predefined value `:keys_only`, `:all`; `:keys_only` is a default,
 * `name` - an index will be created with this name when a table is
   created; by default name is generated and contains table name and keys
   names,
-* `read_capacity` - is used when table creates and used as an index
+* `read_capacity` - is used when table created and used as an index
   capacity; by default equals `Dynamoid::Config.read_capacity`,
-* `write_capacity` - is used when table creates and used as an index
+* `write_capacity` - is used when table created and used as an index
   capacity; by default equals `Dynamoid::Config.write_capacity`
 
 The only mandatory option is `name`.
@@ -954,7 +1016,7 @@ on the base table*
 
 Listed below are all configuration options.
 
-* `adapter` - usefull only for the gem developers to switch to a new
+* `adapter` - useful only for the gem developers to switch to a new
   adapter. Default and the only available value is `aws_sdk_v3`
 * `namespace` - prefix for table names, default is
   `dynamoid_#{application_name}_#{environment}` for Rails application
@@ -962,15 +1024,21 @@ Listed below are all configuration options.
 * `logger` - by default it's a `Rails.logger` in Rails application and
   `stdout` otherwise. You can disable logging by setting `nil` or
   `false` values. Set `true` value to use defaults
-* `access_key` - DynamoDb custom credentials for AWS, override global
-  AWS credentials if they present
-* `secret_key` - DynamoDb custom credentials for AWS, override global
-  AWS credentials if they present
+* `access_key` - DynamoDb custom access key for AWS credentials, override global
+  AWS credentials if they're present
+* `secret_key` - DynamoDb custom secret key for AWS credentials, override global
+  AWS credentials if they're present
+* `credentials` - DynamoDb custom pre-configured credentials, override global
+  AWS credentials if they're present
 * `region` - DynamoDb custom credentials for AWS, override global AWS
-  credentials if they present
+  credentials if they're present
 * `batch_size` - when you try to load multiple items at once with
 * `batch_get_item` call Dynamoid loads them not with one api call but
   piece by piece. Default is 100 items
+* `capacity_mode` - used at a table creation and means whether a table
+  read/write capacity mode will be on-demand or provisioned. Allowed
+  values are `:on_demand` and `:provisioned`. Default value is `nil` which
+  means provisioned mode will be used.
 * `read_capacity` - is used at table or indices creation. Default is 100
   (units)
 * `write_capacity` - is used at table or indices creation. Default is 20
@@ -984,7 +1052,7 @@ Listed below are all configuration options.
   when referring to them. Isn't thread safe. Default is `false`.
   `Use Dynamoid::Middleware::IdentityMap` to clear identity map for each HTTP request
 * `timestamps` - by default Dynamoid sets `created_at` and `updated_at`
-  fields for model at creation and updating. You can disable this
+  fields for model creation and updating. You can disable this
   behavior by setting `false` value
 * `sync_retry_max_times` - when Dynamoid creates or deletes table
   synchronously it checks for completion specified times. Default is 60
@@ -1024,7 +1092,7 @@ Listed below are all configuration options.
   100-continue HTTP response before sending the request body. Default
   option value is `nil`. If not specified effected value is `1`
 * `http_idle_timeout`: The number of seconds an HTTP connection is
-  allowed to sit idble before it is considered stale. Default option
+  allowed to sit idle before it is considered stale. Default option
   value is `nil`. If not specified effected value is `5`
 * `http_open_timeout`: The number of seconds to wait when opening a HTTP
   session. Default option value is `nil`. If not specified effected
@@ -1056,7 +1124,7 @@ reload the row (so that it will pick up the newest values), and try the
 save again.
 
 Calls to `update` and `update!` also increment the `lock_version`,
-however they do not check the existing value. This guarantees that a
+however, they do not check the existing value. This guarantees that a
 update operation will raise an exception in a concurrent save operation,
 however a save operation will never cause an update to fail. Thus,
 `update` is useful & safe only for doing atomic operations (e.g.
@@ -1102,7 +1170,7 @@ Dynamoid.configure do |config|
 end
 ```
 
-You can use your own strategy in following way:
+You can use your own strategy in the following way:
 
 ```ruby
 Dynamoid.configure do |config|

data/lib/dynamoid/adapter.rb

@@ -124,8 +124,12 @@ module Dynamoid
 
     def create_table(table_name, key, options = {})
       unless tables.include?(table_name)
-        benchmark('Create Table') { adapter.create_table(table_name, key, options) }
+        result = nil
+        benchmark('Create Table') { result = adapter.create_table(table_name, key, options) }
         tables << table_name
+        result
+      else
+        false
       end
     end
 

data/lib/dynamoid/adapter_plugin/aws_sdk_v3.rb

@@ -75,11 +75,18 @@ module Dynamoid
         (Dynamoid::Config.settings.compact.keys & CONNECTION_CONFIG_OPTIONS).each do |option|
           @connection_hash[option] = Dynamoid::Config.send(option)
         end
-        if Dynamoid::Config.access_key?
-          @connection_hash[:access_key_id] = Dynamoid::Config.access_key
-        end
-        if Dynamoid::Config.secret_key?
-          @connection_hash[:secret_access_key] = Dynamoid::Config.secret_key
+
+        # if credentials are passed, they already contain access key & secret key
+        if Dynamoid::Config.credentials?
+          connection_hash[:credentials] = Dynamoid::Config.credentials
+        else
+          # otherwise, pass access key & secret key for credentials creation
+          if Dynamoid::Config.access_key?
+            connection_hash[:access_key_id] = Dynamoid::Config.access_key
+          end
+          if Dynamoid::Config.secret_key?
+            connection_hash[:secret_access_key] = Dynamoid::Config.secret_key
+          end
         end
 
         # https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-core/lib/aws-sdk-core/plugins/logging.rb
@@ -246,8 +253,22 @@ module Dynamoid
       def create_table(table_name, key = :id, options = {})
         Dynamoid.logger.info "Creating #{table_name} table. This could take a while."
         CreateTable.new(client, table_name, key, options).call
+        true
       rescue Aws::DynamoDB::Errors::ResourceInUseException => e
         Dynamoid.logger.error "Table #{table_name} cannot be created as it already exists"
+        false
+      end
+
+      def update_time_to_live(table_name:, attribute:)
+        request = {
+          table_name: table_name,
+          time_to_live_specification: {
+            attribute_name: attribute,
+            enabled: true,
+          }
+        }
+
+        client.update_time_to_live(request)
       end
 
       # Create a table on DynamoDB *synchronously*.

data/lib/dynamoid/adapter_plugin/aws_sdk_v3/create_table.rb

@@ -16,6 +16,7 @@ module Dynamoid
         end
 
         def call
+          billing_mode = options[:billing_mode]
           read_capacity = options[:read_capacity] || Dynamoid::Config.read_capacity
           write_capacity = options[:write_capacity] || Dynamoid::Config.write_capacity
 
@@ -41,14 +42,20 @@ module Dynamoid
 
           client_opts = {
             table_name: table_name,
-            provisioned_throughput: {
-              read_capacity_units: read_capacity,
-              write_capacity_units: write_capacity
-            },
             key_schema: key_schema,
             attribute_definitions: attribute_definitions
           }
 
+          if billing_mode == :on_demand
+            client_opts[:billing_mode] = 'PAY_PER_REQUEST'
+          else
+            client_opts[:billing_mode] = 'PROVISIONED'
+            client_opts[:provisioned_throughput] = {
+              read_capacity_units: read_capacity,
+              write_capacity_units: write_capacity
+            }
+          end
+
           if ls_indexes.present?
             client_opts[:local_secondary_indexes] = ls_indexes.map do |index|
               index_to_aws_hash(index)

data/lib/dynamoid/components.rb

@@ -14,6 +14,7 @@ module Dynamoid
 
       before_create :set_created_at
       before_save :set_updated_at
+      before_save :set_expires_field
       after_initialize :set_inheritance_field
     end
 

data/lib/dynamoid/config.rb

@@ -10,6 +10,15 @@ require 'dynamoid/config/backoff_strategies/exponential_backoff'
 module Dynamoid
   # Contains all the basic configuration information required for Dynamoid: both sensible defaults and required fields.
   module Config
+    # @since 3.3.1
+    DEFAULT_NAMESPACE = if defined?(Rails)
+                          klass = Rails.application.class
+                          app_name = Rails::VERSION::MAJOR >= 6 ? klass.module_parent_name : klass.parent_name
+                          "dynamoid_#{app_name}_#{Rails.env}".freeze
+                        else
+                          'dynamoid'.freeze
+                        end
+
     extend self
 
     extend Options
@@ -17,11 +26,13 @@ module Dynamoid
 
     # All the default options.
     option :adapter, default: 'aws_sdk_v3'
-    option :namespace, default: defined?(Rails) ? "dynamoid_#{Rails.application.class.parent_name}_#{Rails.env}" : 'dynamoid'
+    option :namespace, default: DEFAULT_NAMESPACE
     option :access_key, default: nil
     option :secret_key, default: nil
+    option :credentials, default: nil
     option :region, default: nil
     option :batch_size, default: 100
+    option :capacity_mode, default: nil
     option :read_capacity, default: 100
     option :write_capacity, default: 20
     option :warn_on_scan, default: true
@@ -84,5 +95,6 @@ module Dynamoid
         backoff_strategies[backoff].call
       end
     end
+
   end
 end

data/lib/dynamoid/document.rb

@@ -51,6 +51,13 @@ module Dynamoid #:nodoc:
         options[:write_capacity] || Dynamoid::Config.write_capacity
       end
 
+
+      # Returns the billing (capacity) mode for this table.
+      # Could be either :provisioned or :on_demand
+      def capacity_mode
+        options[:capacity_mode] || Dynamoid::Config.capacity_mode
+      end
+
       # Returns the field name used to support STI for this table.
       def inheritance_field
         options[:inheritance_field] || :type
@@ -138,13 +145,11 @@ module Dynamoid #:nodoc:
         @associations ||= {}
         @attributes_before_type_cast ||= {}
 
-        attrs_with_defaults = self.class.attributes.reduce({}) do |res, (attribute, options)|
+        attrs_with_defaults = self.class.attributes.each_with_object({}) do |(attribute, options), res|
           if attrs.key?(attribute)
-            res.merge(attribute => attrs[attribute])
+            res[attribute] = attrs[attribute]
           elsif options.key?(:default)
-            res.merge(attribute => evaluate_default_value(options[:default]))
-          else
-            res
+            res[attribute] = evaluate_default_value(options[:default])
           end
         end
 

data/lib/dynamoid/fields.rb

@@ -21,8 +21,11 @@ module Dynamoid #:nodoc:
       class_attribute :range_key
 
       self.attributes = {}
-      field :created_at, :datetime
-      field :updated_at, :datetime
+
+      # Timestamp fields could be disabled later in `table` method call.
+      # So let's declare them here and remove them later if it will be necessary
+      field :created_at, :datetime if Dynamoid::Config.timestamps
+      field :updated_at, :datetime if Dynamoid::Config.timestamps
 
       field :id # Default primary key
     end
@@ -75,12 +78,24 @@ module Dynamoid #:nodoc:
         self.range_key = name
       end
 
-      def table(_options)
+      def table(options)
         # a default 'id' column is created when Dynamoid::Document is included
         unless attributes.key? hash_key
           remove_field :id
           field(hash_key)
         end
+
+        if options[:timestamps] && !Dynamoid::Config.timestamps
+          # Timestamp fields weren't declared in `included` hook because they
+          # are disabled globaly
+          field :created_at, :datetime
+          field :updated_at, :datetime
+        elsif options[:timestamps] == false && Dynamoid::Config.timestamps
+          # Timestamp fields were declared in `included` hook but they are
+          # disabled for a table
+          remove_field :created_at
+          remove_field :updated_at
+        end
       end
 
       def remove_field(field)
@@ -99,6 +114,10 @@ module Dynamoid #:nodoc:
         end
       end
 
+      def timestamps_enabled?
+        options[:timestamps] || (options[:timestamps].nil? && Dynamoid::Config.timestamps)
+      end
+
       private
 
       def generated_methods
@@ -166,18 +185,31 @@ module Dynamoid #:nodoc:
     #
     # @since 0.2.0
     def set_created_at
-      self.created_at ||= DateTime.now.in_time_zone(Time.zone) if Dynamoid::Config.timestamps
+      self.created_at ||= DateTime.now.in_time_zone(Time.zone) if self.class.timestamps_enabled?
     end
 
     # Automatically called during the save callback to set the updated_at time.
     #
     # @since 0.2.0
     def set_updated_at
-      if Dynamoid::Config.timestamps && !updated_at_changed?
+      if self.class.timestamps_enabled? && !updated_at_changed?
         self.updated_at = DateTime.now.in_time_zone(Time.zone)
       end
     end
 
+    def set_expires_field
+      options = self.class.options[:expires]
+
+      if options.present?
+        name = options[:field]
+        seconds = options[:after]
+
+        if self[name].blank?
+          send("#{name}=", Time.now.to_i + seconds)
+        end
+      end
+    end
+
     def set_inheritance_field
       # actually it does only following logic:
       # self.type ||= self.class.name if self.class.attributes[:type]

data/lib/dynamoid/persistence.rb

@@ -46,6 +46,7 @@ module Dynamoid
         options = {
           id: hash_key,
           table_name: table_name,
+          billing_mode: capacity_mode,
           write_capacity: write_capacity,
           read_capacity: read_capacity,
           range_key: range_key_hash,
@@ -54,7 +55,12 @@ module Dynamoid
           global_secondary_indexes: global_secondary_indexes.values
         }.merge(options)
 
-        Dynamoid.adapter.create_table(options[:table_name], options[:id], options)
+        created_successfuly = Dynamoid.adapter.create_table(options[:table_name], options[:id], options)
+
+        if created_successfuly && self.options[:expires]
+          attribute = self.options[:expires][:field]
+          Dynamoid.adapter.update_time_to_live(table_name: table_name, attribute: attribute)
+        end
       end
 
       # Deletes the table for the model

data/lib/dynamoid/persistence/import.rb

@@ -32,7 +32,7 @@ module Dynamoid
       def build_model(attributes)
         attrs = attributes.symbolize_keys
 
-        if Dynamoid::Config.timestamps
+        if @model_class.timestamps_enabled?
           time_now = DateTime.now.in_time_zone(Time.zone)
           attrs[:created_at] ||= time_now
           attrs[:updated_at] ||= time_now

data/lib/dynamoid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dynamoid
-  VERSION = '3.3.0'
+  VERSION = '3.4.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Josh Symonds
@@ -21,7 +21,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-20 00:00:00.000000000 Z
+date: 2019-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -315,8 +315,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Dynamoid is an ORM for Amazon's DynamoDB