all_futures 1.0.3 → 2.0.0

data/bin/console

@@ -4,4 +4,12 @@ require "bundler/setup"
 require "all_futures"
 require "pry"
 
+# Configure Kredis to allow for testing without Redis in order to avoid exception:
+# NoMethodError: undefined method `config_for' for nil:NilClass
+Kredis.configurator = Class.new {
+  def config_for(name)
+    {db: "1"}
+  end
+}.new
+
 Pry.start

data/lib/all_futures/association.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Association
+    def initialize_attributes(record, attributes = {})
+      record.assign_attributes attributes if attributes.any?
+      record._write_attribute(reflection.options[:foreign_key], owner.id) if owner.is_a?(AllFutures::Base)
+      set_inverse_instance(record)
+    end
+  end
+
+  module CollectionAssociationHydration
+    def reader
+      AssociationIndex.hydrate(self)
+      super
+    end
+
+    def size
+      AssociationIndex.hydrate(self)
+      super
+    end
+  end
+
+  module SingularAssociationHydration
+    def reader
+      AssociationIndex.hydrate(self)
+      super
+    end
+  end
+end
+
+class ActiveEntity::Associations::Embeds::Association
+  prepend AllFutures::Association
+end
+
+class ActiveEntity::Associations::Embeds::CollectionAssociation
+  prepend AllFutures::CollectionAssociationHydration
+end
+
+class ActiveEntity::Associations::Embeds::SingularAssociation
+  prepend AllFutures::SingularAssociationHydration
+end

data/lib/all_futures/association_index.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module AllFutures
+  # Maintains Redis SETs that index embedded children by owner so associations
+  # can be lazy-loaded after find without scanning every key of the child class.
+  #
+  # Key shape: "OwnerClass:owner_id:association_name" => SET of child ids
+  module AssociationIndex
+    module_function
+
+    def key(owner_class, owner_id, association_name)
+      "#{owner_class.name}:#{owner_id}:#{association_name}"
+    end
+
+    def add(owner_class, owner_id, association_name, child_id)
+      return if owner_id.blank? || child_id.blank?
+      Kredis.redis.sadd(key(owner_class, owner_id, association_name), child_id.to_s)
+    end
+
+    def remove(owner_class, owner_id, association_name, child_id)
+      return if owner_id.blank? || child_id.blank?
+      Kredis.redis.srem(key(owner_class, owner_id, association_name), child_id.to_s)
+    end
+
+    def clear(owner_class, owner_id, association_name)
+      return if owner_id.blank?
+      Kredis.redis.del(key(owner_class, owner_id, association_name))
+    end
+
+    def member_ids(owner_class, owner_id, association_name)
+      return [] if owner_id.blank?
+      Array(Kredis.redis.smembers(key(owner_class, owner_id, association_name)))
+    end
+
+    def hydrate(association)
+      return if association.instance_variable_get(:@af_hydrated)
+      association.instance_variable_set(:@af_hydrated, true)
+
+      owner = association.owner
+      return unless owner.is_a?(AllFutures::Base) && owner.persisted?
+
+      reflection = association.reflection
+      return unless [:embeds_many, :embeds_one].include?(reflection.macro)
+
+      ids = member_ids(owner.class, owner.id, reflection.name)
+      return if ids.empty?
+
+      existing_ids = Array.wrap(association.target).compact.map { |r| r.id.to_s }
+
+      ids.each do |child_id|
+        next if existing_ids.include?(child_id.to_s)
+
+        begin
+          record = reflection.klass.find(child_id)
+        rescue AllFutures::RecordNotFound
+          remove(owner.class, owner.id, reflection.name, child_id)
+          next
+        end
+
+        if reflection.macro == :embeds_many
+          association.add_to_target(record, true)
+        else
+          association.target = record
+          association.set_inverse_instance(record)
+        end
+      end
+    end
+  end
+end

data/lib/all_futures/attributes.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Attributes
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_future(name, klass, **options)
+        ivar_symbol = :"@#{name}_all_futures"
+
+        define_method(name) do
+          if instance_variable_defined?(ivar_symbol)
+            instance_variable_get(ivar_symbol)
+          else
+            af_key = if options[:key]
+              options[:key]
+            else
+              record_id = try(:id) or raise AllFutures::ParentModelNotSavedYet, "AllFutures requires a unique key. Either save the parent model before accessing #{name}, or pass a custom key."
+              "#{self.class.name.tableize.tr("/", ":")}:#{record_id}:#{name}"
+            end
+            af = klass.exists?(af_key) ? klass.find(af_key) : klass.new(id: af_key)
+            instance_variable_set(ivar_symbol, af)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/all_futures/base.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module AllFutures
+  class Base < ActiveEntity::Base
+    prepend ::AllFutures::Callbacks
+    extend ::ActiveModel::Naming
+    extend ::AllFutures::Translation
+    include ::AllFutures::Persistence
+    include ::AllFutures::Dirty
+    include ::AllFutures::Validations
+    include ::AllFutures::Presenter
+    include ::AllFutures::Versions
+    include ::AllFutures::Finder
+    include ::AllFutures::Embeds
+    include ::ActiveModel::Conversion
+    include ::ActiveModel::SecurePassword
+    include ::ActiveRecord::Integration
+    include ::Kredis::Attributes
+
+    attr_reader :created_at, :updated_at
+
+    def initialize(attributes = {}, &block)
+      attributes ||= {}
+      attributes = attributes.attributes.transform_keys(&:to_sym) if attributes.is_a?(ActiveRecord::Base)
+      attributes_for_super = attributes.key?(:id) ? attributes.except(:id).except(:created_at).except(:updated_at) : attributes
+
+      super(attributes_for_super) do
+        @id = attributes&.fetch(:id, nil) || ULID.generate
+        @created_at = Time.current
+        @updated_at = attributes&.fetch(:updated_at, Time.current)
+        @redis_key = "#{self.class.name}:#{@id}"
+        @new_record = !self.class.exists?(@id)
+        @destroyed = false
+        @previously_new_record = false
+        @_versioning_enabled = self.class.versioning
+        @_versions = {}
+        @_current_version = nil
+        @_id_set = attributes.key?(:id)
+
+        @attributes.keys.each do |attr|
+          define_singleton_method("#{attr}_changed?") { attribute_changed?(attr) }
+          define_singleton_method("#{attr}_valid?") { attribute_valid?(attr) }
+          define_singleton_method("rollback_#{attr}") { rollback_attribute(attr) }
+          define_singleton_method("rollback_#{attr}!") { rollback_attribute!(attr) }
+          define_singleton_method("restore_#{attr}") { restore_attribute(attr) }
+          define_singleton_method("restore_#{attr}!") { restore_attribute(attr) }
+        end
+
+        block&.call(self)
+      end
+    end
+
+    def id
+      (!new_record? || @_id_set) ? @id.to_s : nil
+    end
+
+    def id=(value)
+      raise FrozenError.new("can't modify id when persisted") unless new_record?
+      @id = value.to_s
+      @redis_key = "#{self.class.name}:#{@id}"
+      @_id_set = true
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:all_futures, Base)
+end

data/lib/all_futures/callbacks.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "active_support/callbacks"
+
+module AllFutures
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [:before_save, :after_save, :before_update, :after_update, :before_destroy, :after_destroy]
+
+    def self.prepended(base)
+      base.include(ActiveSupport::Callbacks)
+
+      base.define_callbacks(:save, :update, :destroy, skip_after_callbacks_if_terminated: true) unless base.respond_to?(:_perform_callbacks) && base._perform_callbacks.present?
+
+      class << base
+        prepend ClassMethods
+      end
+    end
+
+    def destroy
+      perform_operation(:destroy)
+    end
+
+    def destroy!
+      perform_operation(:destroy!)
+    end
+
+    def save
+      perform_operation(:save)
+    end
+
+    def save!
+      perform_operation(:save!)
+    end
+
+    def update(attrs = {})
+      perform_operation(:update, attrs)
+    end
+
+    def update!(attrs = {})
+      perform_operation(:update!, attrs)
+    end
+
+    def perform_operation(operation, *args)
+      if respond_to?(:run_callbacks)
+        callback = operation.to_s.sub("!", "").to_sym
+        run_callbacks callback do
+          method(operation).super_method.call(*args)
+        end
+      else
+        method(operation).super_method.call(*args)
+      end
+    end
+
+    module ClassMethods
+      def method_missing(name, *filters, &blk)
+        if CALLBACKS.include? name
+          callback_context, method_name = name.to_s.split("_")
+          set_callback(method_name.to_sym, callback_context.to_sym, *filters, &blk)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_all)
+        CALLBACKS.include?(name) || super
+      end
+    end
+  end
+end

data/lib/all_futures/configuration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AllFutures
+  # When true, versioned models save via a Redis Lua compare-and-set so two
+  # processes cannot both pass a stale check and silently clobber each other.
+  # Default false: the in-process guard rail (GET, check, SET) is enough for
+  # most apps and avoids an EVAL on every write.
+  mattr_accessor :atomic_locking, instance_accessor: false, default: false
+end

data/lib/all_futures/dirty.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Dirty
+    extend ActiveSupport::Concern
+
+    def attribute_change(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      (attribute_was(attribute) == self[attribute]) ? nil : [attribute_was(attribute), self[attribute]]
+    end
+
+    def attribute_changed?(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      changes.key? attribute.to_s
+    end
+    alias_method :attribute_will_change?, :attribute_changed?
+    alias_method :will_save_change_to_attribute?, :attribute_changed?
+
+    def attribute_changed!(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      public_send("#{attribute}_will_change!")
+    end
+
+    def attribute_previous_change(attribute)
+      super
+    end
+
+    def attribute_will_change!(attribute)
+      super
+    end
+
+    def clear_attribute_change(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      super
+    end
+
+    def clear_attribute_changes(attr_names = changed)
+      super
+    end
+
+    def dirty?
+      changes.any?
+    end
+    alias_method :changed_attributes?, :dirty?
+    alias_method :has_changes_to_save?, :dirty?
+
+    def previous_attributes
+      attribute_names.each_with_object({}) do |attribute, hash|
+        hash[attribute] = attribute_previously_was(attribute)
+      end
+    end
+
+    def mutations_before_last_save
+      super
+    end
+
+    def restore_attribute(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      attribute = attribute.to_s
+      if attribute_changed?(attribute)
+        self[attribute] = attribute_was(attribute)
+        clear_attribute_change(attribute)
+      end
+    end
+
+    def restore_attributes(attr_names = changed)
+      attr_names.each { |attribute| _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s) }.each { |attribute| restore_attribute(attribute) }
+    end
+
+    def rollback_attribute(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      if self[attribute] != attribute_previously_was(attribute)
+        self[attribute] = attribute_previously_was(attribute)
+        clear_attribute_change(attribute)
+      end
+    end
+
+    def rollback_attribute!(attribute)
+      _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s)
+      # unlike rollback_attribute, keep the mutation tracked so save sees a dirty record
+      self[attribute] = attribute_previously_was(attribute) if self[attribute] != attribute_previously_was(attribute)
+      save
+    end
+
+    def rollback_attributes(attr_names = changed)
+      attr_names.each { |attribute| _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s) }.each { |attribute| rollback_attribute(attribute) }
+    end
+
+    def rollback_attributes!(attr_names = changed)
+      attr_names.each { |attribute| _raise_unknown_attribute_error(attribute) unless attributes.key?(attribute.to_s) }
+      attr_names.each { |attribute| self[attribute] = attribute_previously_was(attribute) if self[attribute] != attribute_previously_was(attribute) }
+      save
+    end
+
+    def saved_changes?
+      saved_changes.any?
+    end
+    alias_method :previous_changes?, :saved_changes?
+
+    def saved_changes
+      attributes.select { |attribute| attribute_previously_changed? attribute }
+    end
+
+    module ClassMethods
+      def set_previous_attributes(model, record)
+        tracker = ActiveModel::AttributeMutationTracker.new(model.instance_variable_get(:@attributes))
+        previous_values = tracker.instance_variable_get(:@attributes).instance_variable_get(:@attributes)
+        previous_values.each do |key, attribute|
+          original = attribute.instance_variable_get(:@original_attribute)
+          original&.instance_variable_set(:@value_before_type_cast, record["previous_attributes"][key])
+        end
+        model.instance_variable_set :@mutations_before_last_save, tracker
+      end
+    end
+  end
+end

data/lib/all_futures/embeds.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Embeds
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def embedded_in(name, **options)
+        autosave = options.delete(:autosave)
+        dependent = options.delete(:dependent)
+        foreign_key = options.delete(:foreign_key)
+        embeds = super
+        embeds[name.to_s].options[:autosave] = autosave
+        embeds[name.to_s].options[:dependent] = dependent
+        # FK lives on the child and points at the parent: government_id, not spy_id
+        embeds[name.to_s].options[:foreign_key] = foreign_key || "#{name}_id"
+      end
+
+      def embeds_one(name, **options)
+        autosave = options.delete(:autosave)
+        dependent = options.delete(:dependent)
+        foreign_key = options.delete(:foreign_key)
+        embeds = super
+        embeds[name.to_s].options[:autosave] = autosave
+        embeds[name.to_s].options[:dependent] = dependent
+        embeds[name.to_s].options[:foreign_key] = foreign_key || model_name.singular + "_id"
+      end
+
+      def embeds_many(name, **options)
+        autosave = options.delete(:autosave)
+        dependent = options.delete(:dependent)
+        foreign_key = options.delete(:foreign_key)
+        embeds = super
+        embeds[name.to_s].options[:autosave] = autosave
+        embeds[name.to_s].options[:dependent] = dependent
+        embeds[name.to_s].options[:foreign_key] = foreign_key || model_name.singular + "_id"
+      end
+    end
+  end
+end

data/lib/all_futures/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AllFutures
+  class DeleteRestrictionError < StandardError
+    def initialize(name = nil)
+      if name
+        super("Cannot delete record because of dependent #{name}")
+      else
+        super("Delete restriction error.")
+      end
+    end
+  end
+
+  class InvalidAttribute < StandardError; end
+
+  class InvalidDependentOption < StandardError; end
+
+  class MissingForeignKeyError < StandardError; end
+
+  class ParentModelNotSavedYet < StandardError; end
+
+  class ReadOnlyRecord < StandardError; end
+
+  class RecordInvalid < StandardError; end
+
+  class RecordNotFound < StandardError; end
+
+  class RecordNotDestroyed < StandardError; end
+
+  class RecordNotSaved < StandardError; end
+
+  class RecordStale < StandardError; end
+
+  class SoleRecordExceeded < StandardError; end
+
+  class VersionNotFound < StandardError; end
+end