mobility 0.8.8 → 0.8.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 157698dc2cfdf847b956ae45dd3ff8c447800053b07b3b68bf848feefc8e690f
-  data.tar.gz: b711720dae3e3eb480bcd630045daa56873b03f101b623b707c0eb8735b5936a
+  metadata.gz: 792cd0d08532672e8bef3620b2e0741c6dab8bbe7105b80638ac5c0468e02a43
+  data.tar.gz: 76d31ca70d2b207c9612284a934f10b2ea0d68ad56f98ee92e03207323239841
 SHA512:
-  metadata.gz: 22843bcb2a06b050a0b38fe76a970097ea0e1082c2095414419ad1f32fd980f21f7a9853bb471c18a9c6c8bb5786652b0f42e3a6577d17ae103257ddf19da0fe
-  data.tar.gz: 0527fabbd7ed167e6431b8ce2bc9239cf99c13c6f0d2ac9e3074896423fa459453091b54471b43c74f17bbbc2c44af89452854c59313b071828eacc236940590
+  metadata.gz: c8194524ecaa6bd398d911b028f9a4029e374db423887ac1a7e21b68e501290531284c718733795df08b6d9d173033188bb28ac57c1aca9b897271788a812a7c
+  data.tar.gz: a89d634b7350cf01758cc929d36e354376ac9c2f9ee08b183e24f0200377756ba6950cd5d80b62b045527cbb43cf5a0c1e739564f1890b81bbfbcf68c8800cd5

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## 0.8
 
+### 0.8.9 (October 25, 2019)
+* Fix Dirty plugin to work with Rails 6
+  ([#343](https://github.com/shioyama/mobility/pull/343),
+  [#348](https://github.com/shioyama/mobility/pull/348),
+  [#352](https://github.com/shioyama/mobility/pull/352) on master branch, plus
+  [#351](https://github.com/shioyama/mobility/pull/351) to sync to 0-8-stable
+  branch). Summary of changes
+  [here](https://github.com/shioyama/mobility/pull/347#issuecomment-544742401).
+
 ### 0.8.8 (September 18, 2019)
 * Accept any number of arguments to `Arel::Visitors::Visitor#visit`
   ([#339](https://github.com/shioyama/mobility/pull/339)). (Thanks to

data/Gemfile

@@ -11,11 +11,11 @@ group :development, :test do
       gem 'activerecord', '>= 4.2.6', '< 5.0'
     elsif ENV['RAILS_VERSION'] == '5.1'
       gem 'activerecord', '>= 5.1', '< 5.2'
-    elsif ENV['RAILS_VERSION'] == 'latest'
-      gem 'activerecord', '>= 6.0.0.beta1'
-    else # Default is Rails 5.2
+    elsif ENV['RAILS_VERSION'] == '5.2'
       gem 'activerecord', '>= 5.2.0', '< 5.3'
       gem 'railties', '>= 5.2.0.rc2', '< 5.3'
+    else # Default is Rails 6.0
+      gem 'activerecord', '>= 6.0.0', '< 6.1'
     end
     gem "generator_spec", '~> 0.9.4'
   elsif ENV['ORM'] == 'sequel'
@@ -31,7 +31,11 @@ group :development, :test do
   platforms :ruby do
     gem 'guard-rspec'
     gem 'pry-byebug'
-    gem 'sqlite3', '~> 1.3.6'
+    if ENV['ORM'] == 'active_record' && ENV['RAILS_VERSION'] < '5.2'
+      gem 'sqlite3', '~> 1.3.13'
+    else
+      gem 'sqlite3', '~> 1.4.1'
+    end
     gem 'mysql2', '~> 0.4.9'
     gem 'pg', '< 1.0'
   end

data/README.md

@@ -51,7 +51,7 @@ Installation
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'mobility', '~> 0.8.8'
+gem 'mobility', '~> 0.8.9'
 ```
 
 Mobility is cryptographically signed. To be sure the gem you install hasn't
@@ -68,7 +68,7 @@ installation of unsigned dependencies.
 ### ActiveRecord (Rails)
 
 Requirements:
-- ActiveRecord >= 5.0
+- ActiveRecord >= 5.0 (including 6.0)
 
 (Support for most backends and features is also supported with
 ActiveRecord/Rails 4.2, but there are some tests still failing. To see exactly

data/lib/mobility/plugins/active_model/dirty.rb

@@ -17,81 +17,302 @@ following methods:
 - +title_previous_change+
 - +restore_title!+
 
-In addition, the private method +restore_attribute!+ will also restore the
-value of the translated attribute if passed to it.
+The following methods are also patched to work with translated attributes:
+- +changed_attributes+
+- +changes+
+- +changed+
+- +changed?+
+- +previous_changes+
+- +clear_attribute_changes+
+- +restore_attributes+
+
+In addition, the following ActiveModel attribute handler methods are also
+patched to work with translated attributes:
+- +attribute_changed?+
+- +attribute_previously_changed?+
+- +attribute_was+
+
+(When using these methods, you must pass the attribute name along with its
+locale suffix, so +title_en+, +title_pt_br+, etc.)
+
+Other methods are also included for ActiveRecord models, see documentation on
+the ActiveRecord dirty plugin for more information.
 
 @see http://api.rubyonrails.org/classes/ActiveModel/Dirty.html Rails documentation for Active Model Dirty module
 
 =end
       module Dirty
-        # @!group Backend Accessors
-        # @!macro backend_writer
-        # @param [Hash] options
-        def write(locale, value, options = {})
-          locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
-          if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
-            model.send(:attributes_changed_by_setter).except!(locale_accessor)
-          elsif read(locale, options.merge(locale: true)) != value
-            model.send(:mobility_changed_attributes) << locale_accessor
-            model.send(:attribute_will_change!, locale_accessor)
-          end
-          super
-        end
-        # @!endgroup
-
         # Builds module which adds suffix/prefix methods for translated
         # attributes so they act like normal dirty-tracked attributes.
         class MethodsBuilder < Module
+          delegate :dirty_class, :handler_methods_module, :method_patterns, to: :class
+
           def initialize(*attribute_names)
+            define_dirty_methods(attribute_names)
+          end
+
+          def included(model_class)
+            model_class.include InstanceMethods
+            model_class.include handler_methods_module
+
+            # In earlier versions of Rails, these methods are private
+            %i[clear_attribute_changes clear_changes_information changes_applied].each do |method_name|
+              if dirty_class.private_instance_methods.include?(method_name)
+                model_class.class_eval { private method_name }
+              end
+            end
+          end
+
+          def append_locale(attr_name)
+            Mobility.normalize_locale_accessor(attr_name)
+          end
+
+          private
+
+          def define_dirty_methods(attribute_names)
+            m = self
+
             attribute_names.each do |name|
-              method_suffixes.each do |suffix|
-                define_method "#{name}#{suffix}" do
-                  __send__("attribute#{suffix}", Mobility.normalize_locale_accessor(name))
+              method_patterns.each do |pattern|
+                define_method(pattern % name) do |*args|
+                  mutations_from_mobility.send(pattern % 'attribute', m.append_locale(name), *args)
                 end
               end
 
               define_method "restore_#{name}!" do
-                locale_accessor = Mobility.normalize_locale_accessor(name)
-                if attribute_changed?(locale_accessor)
-                  __send__("#{name}=", changed_attributes[locale_accessor])
+                locale_accessor = m.append_locale(name)
+                if mutations_from_mobility.attribute_changed?(locale_accessor)
+                  __send__("#{name}=", mutations_from_mobility.attribute_was(locale_accessor))
+                  mutations_from_mobility.restore_attribute!(locale_accessor)
                 end
               end
             end
 
+            # This private method override is necessary to make
+            # +restore_attributes+ (which is public) work with translated
+            # attributes.
             define_method :restore_attribute! do |attr|
               attribute_names.include?(attr.to_s) ? send("restore_#{attr}!") : super(attr)
             end
             private :restore_attribute!
           end
 
-          def included(model_class)
-            model_class.include ChangedAttributes
+          class << self
+            def handler_methods_module
+              @handler_methods_module ||= (AttributeHandlerMethods.new.tap do |mod|
+                public_method_patterns.each do |pattern|
+                  method_name = pattern % 'attribute'
+
+                  mod.module_eval <<-EOM, __FILE__, __LINE__ + 1
+                  def #{method_name}(attr_name, *rest)
+                    if (mutations_from_mobility.attribute_changed?(attr_name) ||
+                        mutations_from_mobility.attribute_previously_changed?(attr_name))
+                      mutations_from_mobility.send(#{method_name.inspect}, attr_name, *rest)
+                    else
+                      super
+                    end
+                  end
+                  EOM
+                end
+              end)
+            end
+
+            # Get method suffixes. Creating an object just to get the list of
+            # suffixes is simplest given they change from Rails version to version.
+            def method_patterns
+              @method_patterns ||=
+                (dirty_class.attribute_method_matchers.map { |p| "#{p.prefix}%s#{p.suffix}" } - excluded_method_patterns)
+            end
+
+            def public_method_patterns
+              @public_method_patterns ||= method_patterns.select do |p|
+                !dirty_class.private_instance_methods.include?(:"#{p % 'attribute'}")
+              end
+            end
+
+            def dirty_class
+              @dirty_class ||= Class.new { include ::ActiveModel::Dirty }
+            end
+
+            private
+
+            def excluded_method_patterns
+              ['%s', 'restore_%s!']
+            end
+          end
+        end
+
+        module InstanceMethods
+          def changed_attributes
+            super.merge(mutations_from_mobility.changed_attributes)
+          end
+
+          def changes_applied
+            super
+            mutations_from_mobility.finalize_changes
+          end
+
+          def changes
+            super.merge(mutations_from_mobility.changes)
+          end
+
+          def changed
+            # uniq is required for Rails < 6.0
+            (super + mutations_from_mobility.changed).uniq
+          end
+
+          def changed?
+            super || mutations_from_mobility.changed?
+          end
+
+          def previous_changes
+            super.merge(mutations_from_mobility.previous_changes)
+          end
+
+          def clear_changes_information
+            @mutations_from_mobility = nil
+            super
+          end
+
+          def clear_attribute_changes(attr_names)
+            attr_names.each { |attr_name| mutations_from_mobility.restore_attribute!(attr_name) }
+            super
           end
 
           private
 
-          # Get method suffixes. Creating an object just to get the list of
-          # suffixes is not very efficient, but the most reliable way given that
-          # they change from Rails version to version.
-          def method_suffixes
-            @method_suffixes ||=
-              Class.new do
-                include ::ActiveModel::Dirty
-              end.attribute_method_matchers.map(&:suffix).select { |m| m =~ /\A_/ }
-          end
-
-          # Tracks which translated attributes have been changed, separate from
-          # the default tracking of changes in ActiveModel/ActiveRecord Dirty.
-          # This is required in order for the Mobility ActiveRecord Dirty
-          # plugin to correctly read the value of locale accessors like
-          # +title_en+ in dirty tracking.
-          module ChangedAttributes
-            private
+          def mutations_from_mobility
+            @mutations_from_mobility ||= MobilityMutationTracker.new(self)
+          end
+        end
+
+        # Give the module builder a name so it's easier to see in the model's ancestors
+        class AttributeHandlerMethods < Module; end
+
+        class MobilityMutationTracker
+          OPTION_NOT_GIVEN = Object.new
+
+          attr_reader :previous_changes
+
+          def initialize(model)
+            @model = model
+            @current_changes = {}.with_indifferent_access
+            @previous_changes = {}.with_indifferent_access
+          end
+
+          def finalize_changes
+            @previous_changes = changes
+            @current_changes = {}.with_indifferent_access
+          end
+
+          def changed
+            attr_names.select { |attr_name| attribute_changed?(attr_name) }
+          end
+
+          def changed_attributes
+            attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+              if attribute_changed?(attr_name)
+                result[attr_name] = attribute_was(attr_name)
+              end
+            end
+          end
+
+          def changes
+            attr_names.each_with_object({}.with_indifferent_access) do |attr_name, result|
+              if change = attribute_change(attr_name)
+                result.merge!(attr_name => change)
+              end
+            end
+          end
+
+          def changed?
+            attr_names.any? { |attr| attribute_changed?(attr) }
+          end
+
+          def attribute_change(attr_name)
+            if attribute_changed?(attr_name)
+              [attribute_was(attr_name), fetch_value(attr_name)]
+            end
+          end
+
+          def attribute_previous_change(attr_name)
+            previous_changes[attr_name]
+          end
 
-            def mobility_changed_attributes
-              @mobility_changed_attributes ||= Set.new
+          def attribute_previously_was(attr_name)
+            if attribute_previously_changed?(attr_name)
+              # Calling +first+ here fetches the value before change from the
+              # hash.
+              previous_changes[attr_name].first
             end
           end
+
+          def attribute_changed?(attr_name, from: OPTION_NOT_GIVEN, to: OPTION_NOT_GIVEN)
+            current_changes.include?(attr_name) &&
+              (OPTION_NOT_GIVEN == from || attribute_was(attr_name) == from) &&
+              (OPTION_NOT_GIVEN == to || fetch_value(attr_name) == to)
+          end
+
+          def attribute_previously_changed?(attr_name)
+            previous_changes.include?(attr_name)
+          end
+
+          def attribute_was(attr_name)
+            if attribute_changed?(attr_name)
+              current_changes[attr_name]
+            else
+              fetch_value(attr_name)
+            end
+          end
+
+          def attribute_will_change!(attr_name)
+            current_changes[attr_name] = fetch_value(attr_name) unless current_changes.include?(attr_name)
+          end
+
+          def restore_attribute!(attr_name)
+            current_changes.delete(attr_name)
+          end
+
+          # These are for ActiveRecord, but we'll define them here.
+          alias_method :saved_change_to_attribute?,     :attribute_previously_changed?
+          alias_method :saved_change_to_attribute,      :attribute_previous_change
+          alias_method :attribute_before_last_save,     :attribute_previously_was
+          alias_method :will_save_change_to_attribute?, :attribute_changed?
+          alias_method :attribute_change_to_be_saved,   :attribute_change
+          alias_method :attribute_in_database,          :attribute_was
+
+          private
+          attr_reader :model, :current_changes
+
+          def attr_names
+            current_changes.keys
+          end
+
+          def fetch_value(attr_name)
+            model.__send__(attr_name)
+          end
+        end
+
+        module BackendMethods
+          # @!group Backend Accessors
+          # @!macro backend_writer
+          # @param [Hash] options
+          def write(locale, value, options = {})
+            locale_accessor = Mobility.normalize_locale_accessor(attribute, locale)
+            if model.changed_attributes.has_key?(locale_accessor) && model.changed_attributes[locale_accessor] == value
+              mutations_from_mobility.restore_attribute!(locale_accessor)
+            elsif read(locale, options.merge(locale: true)) != value
+              mutations_from_mobility.attribute_will_change!(locale_accessor)
+            end
+            super
+          end
+          # @!endgroup
+
+          private
+
+          def mutations_from_mobility
+            model.send(:mutations_from_mobility)
+          end
         end
       end
     end

data/lib/mobility/plugins/active_record/dirty.rb

@@ -12,7 +12,6 @@ details on usage.
 In addition to methods added by {Mobility::Plugins::ActiveModel::Dirty}, the
 AR::Dirty plugin adds support for the following persistence-specific methods
 (for a model with a translated attribute +title+):
-- +saved_changes+
 - +saved_change_to_title?+
 - +saved_change_to_title+
 - +title_before_last_save+
@@ -20,128 +19,83 @@ AR::Dirty plugin adds support for the following persistence-specific methods
 - +title_change_to_be_saved+
 - +title_in_database+
 
+The following methods are also patched to include translated attribute changes:
+- +saved_changes+
+- +has_changes_to_save?+
+- +changes_to_save+
+- +changed_attribute_names_to_save+
+- +attributes_in_database+
+
+In addition, the following ActiveModel attribute handler methods are also
+patched to work with translated attributes:
+- +saved_change_to_attribute?+
+- +saved_change_to_attribute+
+- +attribute_before_last_save+
+- +will_save_change_to_attribute?+
+- +attribute_change_to_be_saved+
+- +attribute_in_database+
+
+(When using these methods, you must pass the attribute name along with its
+locale suffix, so +title_en+, +title_pt_br+, etc.)
+
 =end
       module Dirty
-        include ActiveModel::Dirty
-
-        # Builds module which patches a few AR methods to handle changes to
-        # translated attributes just like normal attributes.
         class MethodsBuilder < ActiveModel::Dirty::MethodsBuilder
-          def initialize(*attribute_names)
-            super
-            @attribute_names = attribute_names
-            define_method_overrides if ::ActiveRecord::VERSION::STRING < '5.2'
-            define_attribute_methods if ::ActiveRecord::VERSION::STRING >= '5.1'
-          end
-
-          # Overrides +ActiveRecord::AttributeMethods::ClassMethods#has_attribute+ (in AR 5.1) and
-          # +ActiveModel::AttributeMethods#_read_attribute+ (in AR >= 5.2) to
-          # ensure that fallthrough attribute methods are treated like "real"
-          # attribute methods.
-          #
-          # @note Patching +has_attribute?+ is necessary in AR 5.1 due to this commit[https://github.com/rails/rails/commit/4fed08fa787a316fa51f14baca9eae11913f5050].
           # @param [Attributes] attributes
           def included(model_class)
             super
 
-            if ::ActiveRecord::VERSION::MAJOR == 5 && ::ActiveRecord::VERSION::MINOR == 1
-              names = @attribute_names
-              method_name_regex = /\A(#{names.join('|')})_([a-z]{2}(_[a-z]{2})?)(=?|\??)\z/.freeze
-              has_attribute = Module.new do
-                define_method :has_attribute? do |attr_name|
-                  super(attr_name) || (String === attr_name && !!method_name_regex.match(attr_name))
-                end
-              end
-              model_class.extend has_attribute
-            elsif ::ActiveRecord::VERSION::STRING >= '5.2'
-              model_class.include ReadAttribute
-            end
+            model_class.include InstanceMethods
           end
 
-          private
-
-          # @note These method overrides are needed for AR versions < 5.2,
-          #   since AR::Dirty overrides AM::Dirty, disabling previous_changes
-          #   from being set. Here we "undo" that.
-          def define_method_overrides
-            changes_applied_method = ::ActiveRecord::VERSION::STRING < '5.1' ? :changes_applied : :changes_internally_applied
-            define_method changes_applied_method do
-              @previously_changed = changes
-              super()
+          class << self
+            def dirty_class
+              @dirty_class ||= (Class.new do
+                # In earlier versions of Rails, these are needed to avoid an
+                # exception when including the AR Dirty module outside of an
+                # AR::Base class. Eventually we should be able to drop them.
+                def self.after_create; end
+                def self.after_update; end
+
+                include ::ActiveRecord::AttributeMethods::Dirty
+              end)
             end
+          end
+        end
 
-            define_method :clear_changes_information do
-              @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
-              super()
+        module InstanceMethods
+          if ::ActiveRecord::VERSION::STRING >= '5.1' # define patterns added in 5.1
+            def saved_changes
+              super.merge(mutations_from_mobility.previous_changes)
             end
 
-            define_method :previous_changes do
-              (@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new).merge(super())
+            def changes_to_save
+              super.merge(mutations_from_mobility.changes)
             end
-          end
 
-          # For AR >= 5.1 only
-          def define_attribute_methods
-            define_method :saved_changes do
-              (@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new).merge(super())
+            def changed_attribute_names_to_save
+              super + mutations_from_mobility.changed
             end
 
-            @attribute_names.each do |name|
-              define_method :"saved_change_to_#{name}?" do
-                previous_changes.include?(Mobility.normalize_locale_accessor(name))
-              end
-
-              define_method :"saved_change_to_#{name}" do
-                previous_changes[Mobility.normalize_locale_accessor(name)]
-              end
-
-              define_method :"#{name}_before_last_save" do
-                previous_changes[Mobility.normalize_locale_accessor(name)].first
-              end
-
-              alias_method :"will_save_change_to_#{name}?", :"#{name}_changed?"
-              alias_method :"#{name}_change_to_be_saved", :"#{name}_change"
-              alias_method :"#{name}_in_database", :"#{name}_was"
+            def attributes_in_database
+              super.merge(mutations_from_mobility.changed_attributes)
             end
-          end
 
-          # Overrides _read_attribute to correctly dispatch reads on translated
-          # attributes to their respective setters, rather than to
-          # +@attributes+, which would otherwise return +nil+.
-          #
-          # For background on why this is necessary, see:
-          # https://github.com/shioyama/mobility/issues/115
-          module ReadAttribute
-            # @note We first check if attributes has the key +attr+ to avoid
-            #   doing any extra work in case this is a "normal"
-            #   (non-translated) attribute.
-            def _read_attribute(attr, *args)
-              if @attributes.key?(attr)
-                super
-              else
-                mobility_changed_attributes.include?(attr) ? __send__(attr) : super
+            if ::ActiveRecord::VERSION::STRING >= '6.0'
+              def has_changes_to_save?
+                super || mutations_from_mobility.changed?
               end
             end
+          end
 
-            # @note This is necessary due to a performance fix in e12607
-            #   which skips setting @previously_changed if @attributes is
-            #   defined. For Mobility models using the Dirty plugin, there will
-            #   be cases where @attributes has been set, but there are *other*
-            #   changes on virtual translated attributes which need to also be
-            #   assigned. In this case, we use the presence of such changed
-            #   virtual attributes as an alternative trigger to set this variable.
-            #
-            #   See:
-            #   - https://github.com/rails/rails/commit/e126078a0e013acfe0a397a8dad33b2c9de78732
-            #   - https://github.com/shioyama/mobility/pull/166
-            def changes_applied
-              if defined?(@attributes) && mobility_changed_attributes.any?
-                @previously_changed = changes
-              end
-              super
+          def reload(*)
+            super.tap do
+              @mutations_from_mobility = nil
             end
           end
         end
+
+        BackendMethods = ActiveModel::Dirty::BackendMethods
       end
     end
   end

data/lib/mobility/plugins/dirty.rb

@@ -50,7 +50,7 @@ details.
             else
               raise ArgumentError, "#{model_class} does not support Dirty module."
             end
-          backend_class.include dirty_module
+          backend_class.include dirty_module.const_get(:BackendMethods)
           model_class.include dirty_module.const_get(:MethodsBuilder).new(*attribute_names)
         end
       end

data/lib/mobility/plugins/sequel/dirty.rb

@@ -13,21 +13,6 @@ Automatically includes dirty plugin in model class when enabled.
 =end
     module Sequel
       module Dirty
-        # @!group Backend Accessors
-        # @!macro backend_writer
-        # @param [Hash] options
-        def write(locale, value, options = {})
-          locale_accessor = Mobility.normalize_locale_accessor(attribute, locale).to_sym
-          if model.column_changes.has_key?(locale_accessor) && model.initial_values[locale_accessor] == value
-            super
-            [model.changed_columns, model.initial_values].each { |h| h.delete(locale_accessor) }
-          elsif read(locale, options.merge(fallback: false)) != value
-            model.will_change_column(locale_accessor)
-            super
-          end
-        end
-        # @!endgroup
-
         # Builds module which overrides dirty methods to handle translated as
         # well as normal (untranslated) attributes.
         class MethodsBuilder < Module
@@ -53,6 +38,23 @@ Automatically includes dirty plugin in model class when enabled.
             model_class.plugin :dirty
           end
         end
+
+        module BackendMethods
+          # @!group Backend Accessors
+          # @!macro backend_writer
+          # @param [Hash] options
+          def write(locale, value, options = {})
+            locale_accessor = Mobility.normalize_locale_accessor(attribute, locale).to_sym
+            if model.column_changes.has_key?(locale_accessor) && model.initial_values[locale_accessor] == value
+              super
+              [model.changed_columns, model.initial_values].each { |h| h.delete(locale_accessor) }
+            elsif read(locale, options.merge(fallback: false)) != value
+              model.will_change_column(locale_accessor)
+              super
+            end
+          end
+          # @!endgroup
+        end
       end
     end
   end

data/lib/mobility/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mobility
-  VERSION = "0.8.8"
+  VERSION = "0.8.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mobility
 version: !ruby/object:Gem::Version
-  version: 0.8.8
+  version: 0.8.9
 platform: ruby
 authors:
 - Chris Salzberg
@@ -35,7 +35,7 @@ cert_chain:
   cbyauX5dx2EyKhuidQ7l3jDOcpFUDWeaqqZllz/0i2LFBILAlYRy82zaspW5k6g3
   YL4OF4e7t6EeQyBoILL36f8LpD9odUTRdNruhmuEtoQ+kchZ
   -----END CERTIFICATE-----
-date: 2019-09-17 00:00:00.000000000 Z
+date: 2019-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: request_store