all_futures 1.0.3 → 2.0.0

data/lib/all_futures/persistence.rb

@@ -0,0 +1,595 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Persistence
+    extend ActiveSupport::Concern
+
+    def decrement(attribute, by = 1)
+      increment attribute, -by
+    end
+
+    def decrement!(attribute, by = 1)
+      increment! attribute, -by
+    end
+
+    def delete
+      catch(:abort) do
+        _destroy_associations
+        _destroy_association_indexes
+        _remove_from_parent_indexes!
+        _delete_record if persisted?
+        @destroyed = true
+        return freeze
+      end
+      false
+    end
+
+    def destroy
+      _raise_readonly_record_error if readonly?
+      delete
+    end
+
+    def destroy!
+      _raise_readonly_record_error if readonly?
+      delete || _raise_record_not_destroyed_error
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def increment(attribute, by = 1)
+      _raise_invalid_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      self[attribute] ||= 0
+      self[attribute] += by
+      self
+    end
+
+    def increment!(attribute, by = 1)
+      increment attribute, by
+      save
+      self
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def previously_new_record?
+      @previously_new_record
+    end
+
+    def persisted?
+      !(@new_record || @destroyed)
+    end
+
+    def reload
+      raise AllFutures::RecordNotSaved.new("Can't load model that hasn't been saved") unless persisted?
+      record = self.class.send(:load_model, id)
+      attributes.each do |key, value|
+        self[key] = record["attributes"][key]
+      end
+      @new_record = false
+      @previously_new_record = false
+      if versioning_enabled?
+        @_current_version = record["current_version"]
+        @_versions = record["versions"].transform_keys(&:to_i)
+      end
+      changes_applied # reloaded values are not user-supplied changes; keeps future dirty tracking alive
+      instance_variable_set :@updated_at, Time.zone.parse(record["updated_at"])
+      instance_variable_set :@marked_for_destruction, false
+      instance_variable_set :@destroyed_by_association, nil
+      self.class.send(:set_previous_attributes, self, record)
+      self
+    end
+
+    def save
+      _create_or_update
+    rescue AllFutures::RecordInvalid
+      false
+    end
+
+    def save!
+      _create_or_update || _raise_record_not_saved_error
+    end
+
+    def toggle(attribute)
+      _raise_invalid_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      self[attribute] = !public_send("#{attribute}?")
+      self
+    end
+
+    def toggle!(attribute)
+      _raise_invalid_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      toggle attribute
+      update_attribute attribute, self[attribute]
+    end
+
+    def update(attrs)
+      assign_attributes attrs
+      save
+    end
+
+    def update!(attrs)
+      assign_attributes attrs
+      save!
+    end
+
+    def update_attribute(attribute, value)
+      _raise_invalid_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      _raise_readonly_attribute_error(attribute) if attr_readonly_enabled? && readonly_attribute?(attribute) && attribute_will_change?(attribute)
+      write_attribute attribute, value
+
+      touch
+
+      save
+    end
+
+    def touch
+      @updated_at = Time.current
+    end
+
+    # treat as private
+
+    def _changed_for_autosave?
+      new_record? || has_changes_to_save? || marked_for_destruction? || _nested_records_changed_for_autosave?
+    end
+
+    def _nested_records_changed_for_autosave?
+      @_nested_records_changed_for_autosave_already_called ||= false
+      return false if @_nested_records_changed_for_autosave_already_called
+      begin
+        @_nested_records_changed_for_autosave_already_called = true
+        _reflections.values.any? do |reflection|
+          if reflection.options[:autosave]
+            association = association_instance_get(reflection.name)
+            association && Array.wrap(association.target).any?(&:_changed_for_autosave?)
+          end
+        end
+      ensure
+        @_nested_records_changed_for_autosave_already_called = false
+      end
+    end
+
+    private
+
+    def _association_foreign_key_changed?(reflection, record, key)
+      record._has_attribute?(reflection.options[:foreign_key]) && record._read_attribute(reflection.options[:foreign_key]) != key
+    end
+
+    def _associated_records_to_validate_or_save(association, new_record, autosave)
+      if new_record || _custom_validation_context?
+        association&.target
+      elsif autosave
+        association.target.find_all(&:_changed_for_autosave?)
+      else
+        association.target.find_all(&:new_record?)
+      end
+    end
+
+    def _association_valid?(reflection, record, index = nil)
+      return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
+
+      context = validation_context if _custom_validation_context?
+
+      unless (valid = record.valid?(context))
+        if reflection.options[:autosave]
+          record.errors.group_by_attribute.each do |attribute, errors|
+            errors.each do |error|
+              self.errors.import(error, attribute: "#{reflection.name}.#{attribute}")
+            end
+          end
+        else
+          errors.add(reflection.name)
+        end
+      end
+      valid
+    end
+
+    def _create_or_update
+      _raise_readonly_record_error if readonly?
+      attributes.each_key { |attribute| _raise_readonly_attribute_error(attribute) if attr_readonly_enabled? && readonly_attribute?(attribute) && attribute_will_change?(attribute) }
+      return false if destroyed?
+
+      # capture before changes_applied resets dirty tracking; _save_record uses
+      # this to skip the Redis write (and version bump) when nothing changed
+      @_pending_write = new_record? || dirty?
+
+      changes_applied
+
+      previously_new_record_before_save = (@new_record_before_save ||= false)
+      @new_record_before_save = !previously_new_record_before_save && new_record?
+
+      _reflections.values.select { |reflection| reflection.macro == :embedded_in }.each do |reflection|
+        send(:_save_embedded_in, reflection)
+      end
+
+      result = new_record? ? _create_record : _update_record
+
+      _reflections.values.reject { |reflection| reflection.macro == :embedded_in }.each do |reflection|
+        send("_save_#{reflection.macro}", reflection)
+      end
+
+      @new_record_before_save = previously_new_record_before_save
+
+      result != false
+    end
+
+    def _create_record
+      _save_record
+      @new_record = false
+      @previously_new_record = true
+      _sync_embed_indexes!
+      true
+    end
+
+    def _custom_validation_context?
+      validation_context && [:create, :update].exclude?(validation_context)
+    end
+
+    def _delete_record
+      Kredis.redis.del(@redis_key)
+    end
+
+    def _destroy_associations
+      _reflections.values.each do |reflection|
+        if reflection.options[:dependent]
+          association = association_instance_get(reflection.name)
+          next unless association
+
+          case reflection.options[:dependent]
+          when :delete
+            Array.wrap(association.target).each(&:delete)
+          when :destroy
+            Array.wrap(association.target).each do |record|
+              record.destroyed_by_association = reflection
+              record.destroy
+            end
+          when :nullify
+            raise AllFutures::InvalidDependentOption.new(:nullify) if reflection.macro == :embedded_in
+            Array.wrap(association.target).each do |record|
+              record.update_attribute(reflection.options[:foreign_key], nil) if record.persisted?
+            end
+          when :restrict_with_exception
+            raise AllFutures::InvalidDependentOption.new(:restrict_with_exception) if reflection.macro == :embedded_in
+            raise AllFutures::DeleteRestrictionError.new(reflection.name) unless association.empty?
+          when :restrict_with_error
+            raise AllFutures::InvalidDependentOption.new(:restrict_with_error) if reflection.macro == :embedded_in
+            unless association.empty?
+              record = association.owner.class.human_attribute_name(reflection.name).downcase
+              association.owner.errors.add(:base, :"restrict_dependent_destroy.#{reflection.macro}", record: record)
+              throw(:abort)
+            end
+          end
+        end
+      end
+    end
+
+    def _record_changed?(reflection, record, key)
+      record.new_record? ||
+        _association_foreign_key_changed?(reflection, record, key) ||
+        record.will_save_change_to_attribute?(reflection.options[:foreign_key])
+    end
+
+    def _save_embeds_many(reflection)
+      if (association = association_instance_get(reflection.name))
+        _raise_missing_foreign_key_error(reflection) unless reflection.klass.has_attribute?(reflection.options[:foreign_key])
+        autosave = reflection.options[:autosave]
+
+        new_record_before_save = @new_record_before_save
+
+        if (records = _associated_records_to_validate_or_save(association, new_record_before_save, autosave))
+          if autosave
+            records_to_destroy = records.select(&:marked_for_destruction?)
+            records_to_destroy.each { |record| association.destroy(record) }
+            records -= records_to_destroy
+          end
+
+          records.each do |record|
+            next if record.destroyed?
+
+            saved = true
+            if autosave != false && (new_record_before_save || record.new_record?)
+              association.set_inverse_instance(record)
+
+              record.without_versioning do
+                if autosave
+                  record._write_attribute(reflection.options[:foreign_key], id)
+                  saved = record.save
+                elsif !reflection.nested?
+                  record._write_attribute(reflection.options[:foreign_key], id)
+                  association_saved = record.save
+
+                  if reflection.validate?
+                    errors.add(reflection.name) unless association_saved
+                    saved = association_saved
+                  end
+                end
+              end
+            elsif autosave
+              saved = record.save
+            end
+
+            raise(AllFutures::RecordInvalid.new(association.owner)) unless saved
+          end
+        end
+      end
+    end
+
+    def _save_embeds_one(reflection)
+      association = association_instance_get(reflection.name)
+      _raise_missing_foreign_key_error(reflection) unless reflection.klass.has_attribute?(reflection.options[:foreign_key])
+
+      record = association&.target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          if (autosave && record._changed_for_autosave?) || _record_changed?(reflection, record, id)
+            record._write_attribute(reflection.options[:foreign_key], id)
+            association.set_inverse_instance(record)
+            record.without_versioning { record.save }
+          end
+        end
+      end
+    end
+
+    def _save_embedded_in(reflection)
+      association = association_instance_get(reflection.name)
+      return unless association&.loaded?
+
+      record = association.target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record._write_attribute(reflection.options[:foreign_key], nil)
+          record.destroy
+        elsif autosave != false
+          saved = record.save if record.new_record? || (autosave && record.changed_for_autosave?)
+
+          saved if autosave
+        end
+      end
+    end
+
+    # Redis Lua: compare current_version then SET, or return STALE.
+    # KEYS[1] = redis key, ARGV[1] = expected version ("" if new), ARGV[2] = JSON payload
+    ATOMIC_SAVE_LUA = <<~LUA.freeze
+      local key = KEYS[1]
+      local expected = ARGV[1]
+      local payload = ARGV[2]
+      local raw = redis.call('GET', key)
+
+      if not raw then
+        if expected == '' then
+          redis.call('SET', key, payload)
+          return 'OK'
+        end
+        return 'STALE'
+      end
+
+      local data = cjson.decode(raw)
+      local current = data['current_version']
+      if current == cjson.null or current == nil then
+        current = ''
+      else
+        current = tostring(current)
+      end
+
+      if current == expected then
+        redis.call('SET', key, payload)
+        return 'OK'
+      end
+      return 'STALE'
+    LUA
+
+    def _save_record
+      return true unless @_pending_write
+
+      if versioning_enabled? && AllFutures.atomic_locking
+        _save_record_atomically
+      else
+        _save_version if versioning_enabled?
+        touch
+        Kredis.json(@redis_key).value = _snapshot
+      end
+      true
+    end
+
+    def _save_record_atomically
+      expected = @_current_version
+      previous_version = @_current_version
+      previous_versions = @_versions.dup
+
+      if new_record?
+        @_current_version = 1
+      else
+        @_current_version = @_current_version ? @_current_version.next : 1
+      end
+      @_versions[current_version] = {
+        "attributes" => attributes,
+        "updated_at" => Time.current
+      }
+      touch
+      payload = ActiveSupport::JSON.encode(_snapshot)
+      expected_arg = expected.nil? ? "" : expected.to_s
+
+      result = Kredis.redis.eval(ATOMIC_SAVE_LUA, keys: [@redis_key], argv: [expected_arg, payload])
+      if result == "STALE"
+        @_current_version = previous_version
+        @_versions = previous_versions
+        _raise_record_stale_error
+      end
+    end
+
+    def _sync_embed_indexes!
+      _reflections.values.select { |reflection| reflection.macro == :embedded_in }.each do |reflection|
+        inverse = reflection.inverse_of
+        next unless inverse
+
+        parent_class = reflection.klass
+        next unless parent_class < AllFutures::Base
+
+        fk = reflection.options[:foreign_key]
+        current_parent_id = _read_attribute(fk)
+        previous_parent_id = begin
+          attribute_previously_was(fk)
+        rescue
+          nil
+        end
+
+        if previous_parent_id.present? && previous_parent_id.to_s != current_parent_id.to_s
+          AssociationIndex.remove(parent_class, previous_parent_id, inverse.name, id)
+        end
+
+        if current_parent_id.present?
+          AssociationIndex.add(parent_class, current_parent_id, inverse.name, id)
+        end
+      end
+    end
+
+    def _remove_from_parent_indexes!
+      _reflections.values.select { |reflection| reflection.macro == :embedded_in }.each do |reflection|
+        inverse = reflection.inverse_of
+        next unless inverse
+
+        parent_class = reflection.klass
+        next unless parent_class < AllFutures::Base
+
+        parent_id = _read_attribute(reflection.options[:foreign_key])
+        AssociationIndex.remove(parent_class, parent_id, inverse.name, id) if parent_id.present?
+      end
+    end
+
+    def _destroy_association_indexes
+      return unless id
+
+      _reflections.values.select { |reflection| [:embeds_many, :embeds_one].include?(reflection.macro) }.each do |reflection|
+        AssociationIndex.clear(self.class, id, reflection.name)
+      end
+    end
+
+    def _save_version
+      if new_record?
+        @_current_version = 1
+      else
+        record = Kredis.json(@redis_key).value
+        _raise_record_stale_error if record&.dig("current_version") != @_current_version
+        @_current_version = @_current_version ? @_current_version.next : 1
+      end
+      @_versions[current_version] = {
+        "attributes" => attributes,
+        "updated_at" => Time.current
+      }
+    end
+
+    def _snapshot
+      {
+        attributes: attributes,
+        created_at: created_at,
+        updated_at: @updated_at,
+        previous_attributes: previous_attributes,
+        current_version: current_version,
+        versions: versions.transform_keys(&:to_i)
+      }.deep_transform_keys { |key| key.is_a?(Integer) ? key : key.to_sym }
+    end
+
+    def _raise_invalid_attribute_error(attribute)
+      raise AllFutures::InvalidAttribute.new(self, attribute)
+    end
+
+    def _raise_missing_foreign_key_error(reflection)
+      raise AllFutures::MissingForeignKeyError, "#{reflection.klass} missing foreign key #{reflection.options[:foreign_key]}"
+    end
+
+    def _raise_readonly_attribute_error(attribute)
+      raise AllFutures::ReadOnlyRecord, "#{attribute} is marked as readonly"
+    end
+
+    def _raise_readonly_record_error
+      raise AllFutures::ReadOnlyRecord, "#{self.class} is marked as readonly"
+    end
+
+    def _raise_record_not_destroyed_error
+      raise AllFutures::RecordNotDestroyed, "Failed to destroy the record"
+    end
+
+    def _raise_record_not_saved_error
+      raise AllFutures::RecordNotSaved, "Failed to save the record"
+    end
+
+    def _raise_record_stale_error
+      raise AllFutures::RecordStale, "Failed to save the record because it has been modified by another process"
+    end
+
+    def _update_record
+      _save_record
+      @previously_new_record = false
+      _sync_embed_indexes!
+      true
+    end
+
+    def _validate_single_association(reflection)
+      association = association_instance_get(reflection.name)
+      record = association&.reader
+      _association_valid?(reflection, record) if record && (record._changed_for_autosave? || _custom_validation_context?)
+    end
+
+    def _validate_collection_association(reflection)
+      if (association = association_instance_get(reflection.name))
+        if (records = _associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave]))
+          records.each_with_index { |record, index| _association_valid?(reflection, record, index) }
+        end
+      end
+    end
+
+    module ClassMethods
+      def create(attributes = {}, &block)
+        new(attributes).tap do |record|
+          block&.call(record)
+          record.save
+        end
+      end
+
+      def delete_all
+        Kredis.redis.del Kredis.redis.keys("#{name}:*")
+      end
+
+      def delete_by(attributes = {}, &block)
+        Kredis.redis.del where(attributes, &block).map { |record| "#{name}:#{record.id}" }
+      end
+
+      def destroy_all
+        all.each(&:destroy)
+      end
+
+      def destroy_by(attributes = {}, &block)
+        where(attributes, &block).each(&:destroy)
+      end
+
+      def readonly_attribute?(name)
+        _attr_readonly.include?(name.to_s)
+      end
+
+      private
+
+      def load_model(id)
+        record = Kredis.json("#{name}:#{id}").value
+        raise AllFutures::RecordNotFound.new("Couldn't find #{name} with id #{id}") unless record
+        attribute_names.each do |attribute|
+          case attribute_types[attribute]
+          when ActiveEntity::Type::Date
+            record[attribute] = Date.parse(record[attribute]) if record[attribute]
+          when ActiveEntity::Type::DateTime, ActiveEntity::Type::Time
+            record[attribute] = Time.zone.parse(record[attribute]) if record[attribute]
+          end
+        end
+        record
+      end
+    end
+  end
+end

data/lib/all_futures/presenter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Presenter
+    extend ActiveSupport::Concern
+
+    attr_reader :updated_at
+
+    def max_updated_column_timestamp
+      @updated_at&.to_time
+    end
+
+    def reject
+      attributes
+    end
+
+    def to_dom_id
+      [self.class.name.underscore.dasherize.gsub("/", "--"), id].join("-")
+    end
+
+    def to_h
+      attributes
+    end
+
+    def to_s
+      inspect
+    end
+
+    module ClassMethods
+      def valid_attribute?(attribute)
+        (attribute_names + ["id"]).include?(attribute.to_s)
+      end
+    end
+  end
+end

data/lib/all_futures/railtie.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class AllFutures::Railtie < ::Rails::Railtie
+  config.all_futures = ActiveSupport::OrderedOptions.new
+  config.all_futures.atomic_locking = false
+
+  initializer "all_futures.configure" do |app|
+    AllFutures.atomic_locking = app.config.all_futures.atomic_locking
+  end
+
+  initializer "all_futures.attributes" do
+    config.after_initialize do
+      ActiveModel::Model.include AllFutures::Attributes if defined?(ActiveModel::Model)
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      include AllFutures::Attributes
+    end
+  end
+
+  initializer "all_futures.i18n" do
+    ActiveSupport.on_load(:i18n) do
+      I18n.load_path << File.expand_path("locale/en.yml", __dir__)
+    end
+  end
+end

data/lib/all_futures/translation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Translation
+    include ActiveModel::Translation
+
+    def lookup_ancestors
+      klass = self
+      classes = [klass]
+      return classes if klass == AllFutures::Base
+
+      until klass.base_class?
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    def i18n_scope
+      :allfutures
+    end
+  end
+end

data/lib/all_futures/validations.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Validations
+    def attribute_valid?(attribute)
+      validate
+      errors[attribute].empty?
+    end
+  end
+end

data/lib/all_futures/version.rb

@@ -1,3 +1,5 @@
 # frozen_string_literal: true
 
-VERSION = "1.0.3"
+module AllFutures
+  VERSION = "2.0.0"
+end