all_futures 1.0.2 → 2.0.0

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

data/lib/all_futures/finder.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module AllFutures
+  module Finder
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def all
+        Kredis.redis.scan_each(match: "#{name}:*").map do |key|
+          find(key.delete_prefix("#{name}:"))
+        end.sort_by(&:created_at)
+      end
+
+      def any?(&block)
+        block ? all.any?(&block) : all.any?
+      end
+
+      def count
+        Kredis.redis.keys("#{name}:*").size
+      end
+
+      def exists?(id)
+        return all.any? unless id
+        return false if id == false
+        [Hash, Array].include?(id.class) ? where(id).any? : Kredis.redis.exists?("#{name}:#{id}")
+      end
+
+      def fifth
+        find_nth 4
+      end
+
+      def fifth!
+        fifth || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def find(*ids)
+        raise AllFutures::RecordNotFound.new("Couldn't find #{name} without an id") unless ids.flatten.present?
+        if ids.size == 1 && [String, Integer, Symbol].include?(ids.first.class)
+          record = load_model(ids.first)
+          model = new record["attributes"].merge(id: ids.first)
+          model.changes_applied # loaded values are not user-supplied changes
+          load_versions(model, record)
+          set_previous_attributes(model, record)
+          model.instance_variable_set :@created_at, Time.zone.parse(record["created_at"])
+          model.instance_variable_set :@updated_at, Time.zone.parse(record["updated_at"])
+          model
+        else
+          results = ids.flatten.map do |id|
+            find(id)
+          rescue AllFutures::RecordNotFound
+            nil
+          end
+          return results if results.size == results.compact.size
+          raise AllFutures::RecordNotFound.new("Couldn't find all #{name.pluralize} with ids: #{ids.flatten.join(", ")} (found #{results.compact.size} results, but was looking for #{results.size})")
+        end
+      end
+
+      def find_by(attrs = {})
+        result = where(attrs)
+        result.any? ? result.first : nil
+      end
+
+      def find_by!(attrs = {})
+        result = find_by(attrs)
+        result.present? ? result : raise(AllFutures::RecordNotFound.new("Couldn't find #{name} with #{_pretty_attrs(attrs)}"))
+      end
+
+      def find_or_create_by(attrs = {}, &block)
+        return create({}, &block) unless attrs.present?
+        find_by!(attrs)
+      rescue AllFutures::RecordNotFound
+        create(attrs, &block)
+      end
+
+      def find_or_initialize_by(attrs = {}, &block)
+        return new({}, &block) unless attrs.present?
+        find_by!(attrs)
+      rescue AllFutures::RecordNotFound
+        new(attrs, &block)
+      end
+
+      def find_sole_by(attrs = {}, &block)
+        found, undesired = where(attrs, &block).first(2)
+
+        if found.nil?
+          raise AllFutures::RecordNotFound.new("Couldn't find #{name} record")
+        elsif undesired.present?
+          raise AllFutures::SoleRecordExceeded.new("Found multiple #{name} records when expecting only one")
+        else
+          found
+        end
+      end
+
+      def first(limit = nil)
+        limit ? all.first(limit) : all.first
+      end
+
+      def first!
+        first || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def forty_two
+        find_nth 41
+      end
+
+      def forty_two!
+        forty_two || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def fourth
+        find_nth 3
+      end
+
+      def fourth!
+        fourth || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def ids
+        Kredis.redis.keys("#{name}:*").map { |id| id.delete_prefix("#{name}:") }
+      end
+
+      def include?(record)
+        record.is_a?(self) && exists?(record.id)
+      end
+      alias_method :member?, :include?
+
+      def last(limit = nil)
+        limit ? all.last(limit) : all.last
+      end
+
+      def last!
+        last || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def second
+        find_nth 1
+      end
+
+      def second!
+        second || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def second_to_last
+        find_nth_from_last 1
+      end
+
+      def second_to_last!
+        second_to_last || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def sole
+        found, undesired = first(2)
+
+        if found.nil?
+          raise AllFutures::RecordNotFound.new("Couldn't find #{name} record")
+        elsif undesired.present?
+          raise AllFutures::SoleRecordExceeded.new("Found multiple #{name} records when expecting only one")
+        else
+          found
+        end
+      end
+
+      def third
+        find_nth 2
+      end
+
+      def third!
+        third || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def third_to_last
+        find_nth_from_last 2
+      end
+
+      def third_to_last!
+        third_to_last || raise(AllFutures::RecordNotFound.new("Couldn't find #{name} record"))
+      end
+
+      def where(attrs = {}, &block)
+        if block.blank?
+          return all if attrs.blank?
+          begin
+            return [find(attrs.values.first)] if attrs.one? && attrs.keys.first == :id
+          rescue AllFutures::RecordNotFound
+            return []
+          end
+        end
+
+        attrs.each_key { |key| raise AllFutures::InvalidAttribute.new("#{key} is not a valid attribute") unless valid_attribute?(key) }
+        all.select do |record|
+          attrs.all? do |(attribute, value)|
+            record.send(attribute) == value.to_s
+          end && (block ? block.call(record) : true)
+        end
+      end
+
+      private
+
+      def find_nth(index)
+        records = all
+        (records.size >= index) ? records[index] : nil
+      end
+
+      def find_nth_from_last(index)
+        records = all.reverse
+        (records.size >= index) ? records[index] : nil
+      end
+
+      def _pretty_attrs(attrs)
+        attrs.map { |key, value| "#{key}: #{value}" }.join(", ")
+      end
+    end
+  end
+end