serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/dataset_module.rb

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Model
+    # This Module subclass is used by Model.dataset_module
+    # to add dataset methods to classes.  In addition to the
+    # methods offered by Dataset::DatasetModule, it also
+    # automatically creates class methods for public dataset
+    # methods.
+    class DatasetModule < Dataset::DatasetModule
+      # The model class related to this dataset module.
+      attr_reader :model
+
+      # Store the model related to this dataset module.
+      def initialize(model)
+        @model = model
+      end
+
+      # Alias for where.
+      def subset(name, *args, &block)
+        where(name, *args, &block)
+      end
+
+      private
+
+      # Add a class method to the related model that
+      # calls the dataset method of the same name.
+      def method_added(meth)
+        @model.send(:def_model_dataset_method, meth) if public_method_defined?(meth)
+        super
+      end
+    end
+
+    @dataset_module_class = DatasetModule
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/default_inflections.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+module Sequel
+  # Proc that is instance_execed to create the default inflections for both the
+  # model inflector and the inflector extension.
+  DEFAULT_INFLECTIONS_PROC = proc do
+    plural(/$/, 's')
+    plural(/s$/i, 's')
+    plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/sis$/i, 'ses')
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+    plural(/([m|l])ouse$/i, '\1ice')
+
+    singular(/s$/i, '')
+    singular(/([ti])a$/i, '\1um')
+    singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/([h|t]ive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/([m|l])ice$/i, '\1ouse')
+    singular(/buses$/i, 'bus')
+    singular(/oes$/i, 'o')
+    singular(/shoes$/i, 'shoe')
+    singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/matrices$/i, 'matrix')
+
+    irregular('person', 'people')
+    irregular('man', 'men')
+    irregular('child', 'children')
+    irregular('sex', 'sexes')
+    irregular('move', 'moves')
+    irregular('quiz', 'quizzes')
+    irregular('testis', 'testes')
+
+    uncountable(%w(equipment information rice money species series fish sheep news))
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/errors.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Model
+    # Errors represents validation errors, a simple hash subclass
+    # with a few convenience methods.
+    class Errors < ::Hash
+      # Adds an error for the given attribute.
+      #
+      #   errors.add(:name, 'is not valid') if name == 'invalid'
+      def add(att, msg)
+        fetch(att){self[att] = []} << msg
+      end
+
+      # Return the total number of error messages.
+      #
+      #   errors.count # => 3
+      def count
+        values.inject(0){|m, v| m + v.length}
+      end
+       
+      # Return true if there are no error messages, false otherwise.
+      def empty?
+        count == 0
+      end
+      
+      # Returns an array of fully-formatted error messages.
+      #
+      #   errors.full_messages
+      #   # => ['name is not valid',
+      #   #     'hometown is not at least 2 letters']
+      #
+      # If the message is a Sequel::LiteralString, it will be used literally, without the column name:
+      #
+      #   errors.add(:name, Sequel.lit("Album name is not valid"))
+      #   errors.full_messages
+      #   # => ['Album name is not valid']
+      def full_messages
+        inject([]) do |m, kv| 
+          att, errors = *kv
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : full_message(att, e))}
+          m
+        end
+      end
+      
+      # Returns the array of errors for the given attribute, or nil
+      # if there are no errors for the attribute.
+      #
+      #   errors.on(:name) # => ['name is not valid']
+      #   errors.on(:id) # => nil
+      def on(att)
+        if v = fetch(att, nil) and !v.empty?
+          v
+        end
+      end
+
+      private
+
+      # Create full error message to use for the given attribute (or array of attributes)
+      # and error message. This can be overridden for easier internalization.
+      def full_message(att, error_msg)
+        att = att.join(' and ') if att.is_a?(Array)
+        "#{att} #{error_msg}"
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/exceptions.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  # Exception class raised when +raise_on_save_failure+ is set and an action is canceled in a hook.
+  # or an around hook doesn't yield.
+  class HookFailed < Error
+    # The Sequel::Model instance related to this error.
+    attr_reader :model
+
+    def initialize(message=nil, model=nil)
+      @model = model
+      super(message)
+    end
+  end
+
+  (
+  # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
+  # modify a single row.
+  NoExistingObject = Class.new(Error)
+  ).name
+  
+  (
+  # Raised when an undefined association is used when eager loading.
+  UndefinedAssociation = Class.new(Error)
+  ).name
+
+  # Raised when a mass assignment method is called in strict mode with either a restricted column
+  # or a column without a setter method.
+  class MassAssignmentRestriction < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The column related to this exception, as a string.
+    attr_reader :column
+
+    # Create an instance of this class with the model and column set.
+    def self.create(msg, model, column)
+      e = new("#{msg} for class #{model.class.inspect}")
+      e.instance_variable_set(:@model, model)
+      e.instance_variable_set(:@column, column)
+      e
+    end
+  end
+  
+  # Exception class raised when +raise_on_save_failure+ is set and validation fails
+  class ValidationFailed < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The Sequel::Model::Errors object related to this exception.
+    attr_reader :errors
+
+    def initialize(errors=nil)
+      if errors.is_a?(Sequel::Model)
+        @model = errors
+        errors = @model.errors
+      end
+
+      if errors.respond_to?(:full_messages)
+        @errors = errors
+        super(errors.full_messages.join(', '))
+      else
+        super
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/inflections.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+
+module Sequel
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if defined?(yield)
+    Inflections
+  end
+
+  # This module acts as a singleton returned/yielded by Sequel.inflections,
+  # which is used to override or specify additional inflection rules
+  # for Sequel. Examples:
+  #
+  #   Sequel.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of two element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    instance_exec(&DEFAULT_INFLECTIONS_PROC)
+
+    private
+
+    # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
+    def camelize(s)
+      s = s.to_s
+      return s.camelize if s.respond_to?(:camelize)
+      s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+      s
+    end
+  
+    # Tries to find a declared constant with the name specified
+    # in the string. It raises a NameError when the name is not in CamelCase
+    # or is not initialized.
+    def constantize(s)
+      s = s.to_s
+      return s.constantize if s.respond_to?(:constantize)
+      raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
+      Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+    end
+  
+    # Removes the module part from the expression in the string
+    def demodulize(s)
+      s = s.to_s
+      return s.demodulize if s.respond_to?(:demodulize)
+      s.gsub(/^.*::/, '')
+    end
+  
+    # Returns the plural form of the word in the string.
+    def pluralize(s)
+      s = s.to_s
+      return s.pluralize if s.respond_to?(:pluralize)
+      result = s.dup
+      Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+      result
+    end
+  
+    # The reverse of pluralize, returns the singular form of a word in a string.
+    def singularize(s)
+      s = s.to_s
+      return s.singularize if s.respond_to?(:singularize)
+      result = s.dup
+      Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
+      result
+    end
+  
+    # The reverse of camelize. Makes an underscored form from the expression in the string.
+    # Also changes '::' to '/' to convert namespaces to paths.
+    def underscore(s)
+      s = s.to_s
+      return s.underscore if s.respond_to?(:underscore)
+      s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model/plugins.rb

@@ -0,0 +1,165 @@
+# frozen-string-literal: true
+
+module Sequel
+  # Empty namespace that plugins should use to store themselves,
+  # so they can be loaded via Model.plugin.
+  #
+  # Plugins should be modules with one of the following conditions:
+  # * A singleton method named apply, which takes a model, 
+  #   additional arguments, and an optional block.  This is called
+  #   the first time the plugin is loaded for this model (unless it was
+  #   already loaded by an ancestor class), before including/extending
+  #   any modules, with the arguments
+  #   and block provided to the call to Model.plugin.
+  # * A module inside the plugin module named ClassMethods,
+  #   which will extend the model class.
+  # * A module inside the plugin module named InstanceMethods,
+  #   which will be included in the model class.
+  # * A module inside the plugin module named DatasetMethods,
+  #   which will extend the model's dataset.
+  # * A singleton method named configure, which takes a model, 
+  #   additional arguments, and an optional block.  This is called
+  #   every time the Model.plugin method is called, after including/extending
+  #   any modules.
+  module Plugins
+    # In the given module +mod+, define methods that are call the same method
+    # on the dataset.  This is designed for plugins to define dataset methods
+    # inside ClassMethods that call the implementations in DatasetMethods.
+    #
+    # This should not be called with untrusted input or method names that
+    # can't be used literally, since it uses class_eval.
+    def self.def_dataset_methods(mod, meths)
+      Array(meths).each do |meth|
+        mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
+      end
+    end
+
+    # Add method to +mod+ that overrides inherited_instance_variables to include the
+    # values in this hash.
+    def self.inherited_instance_variables(mod, hash)
+      mod.send(:define_method, :inherited_instance_variables) do ||
+        super().merge!(hash)
+      end
+      mod.send(:private, :inherited_instance_variables)
+    end
+
+    # Add method to +mod+ that overrides set_dataset to call the method afterward.
+    def self.after_set_dataset(mod, meth)
+      mod.send(:define_method, :set_dataset) do |*a|
+        r = super(*a)
+        # Allow calling private class methods as methods this specifies are usually private
+        send(meth)
+        r
+      end
+    end
+
+    method_num = 0
+    method_num_mutex = Mutex.new
+    # Return a unique method name symbol for the given suffix.
+    SEQUEL_METHOD_NAME = lambda do |suffix|
+      :"_sequel_#{suffix}_#{method_num_mutex.synchronize{method_num += 1}}"
+    end
+
+    # Define a private instance method using the block with the provided name and
+    # expected arity.  If the name is given as a Symbol, it is used directly.
+    # If the name is given as a String, a unique name will be generated using
+    # that string.  The expected_arity should be either 0 (no arguments) or
+    # 1 (single argument).
+    #
+    # If a block with an arity that does not match the expected arity is used,
+    # a deprecation warning will be issued. The method defined should still
+    # work, though it will be slower than a method with the expected arity.
+    #
+    # Sequel only checks arity for regular blocks, not lambdas.  Lambdas were
+    # already strict in regards to arity, so there is no need to try to fix
+    # arity to keep backwards compatibility for lambdas.
+    #
+    # Blocks with required keyword arguments are not supported by this method.
+    def self.def_sequel_method(model, meth, expected_arity, &block)
+      if meth.is_a?(String)
+        meth = SEQUEL_METHOD_NAME.call(meth)
+      end
+      call_meth = meth
+
+      unless block.lambda?
+        required_args, optional_args, rest, keyword = _define_sequel_method_arg_numbers(block)
+
+        if keyword == :required
+          raise Error, "cannot use block with required keyword arguments when calling define_sequel_method with expected arity #{expected_arity}"
+        end
+
+        case expected_arity
+        when 0
+          unless required_args == 0
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 0, but arguments required for #{block.inspect}. Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{instance_exec(&b)} # Fallback
+          end
+        when 1
+          if required_args == 0 && optional_args == 0 && !rest
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but no arguments accepted for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            temp_method = SEQUEL_METHOD_NAME.call("temp")
+            model.class_eval("def #{temp_method}(_) #{meth =~ /\A\w+\z/ ? "#{meth}_arity" : "send(:\"#{meth}_arity\")"} end", __FILE__, __LINE__)
+            model.send(:alias_method, meth, temp_method)
+            model.send(:undef_method, temp_method)
+            model.send(:private, meth)
+            meth = :"#{meth}_arity"
+          elsif required_args > 1
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but more arguments required for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{|r| instance_exec(r, &b)} # Fallback
+          end
+        else
+          raise Error, "unexpected arity passed to define_sequel_method: #{expected_arity.inspect}"
+        end
+      end
+
+      model.send(:define_method, meth, &block)
+      model.send(:private, meth)
+      model.send(:alias_method, meth, meth)
+      call_meth
+    end
+
+    # Return the number of required argument, optional arguments,
+    # whether the callable accepts any additional arguments,
+    # and whether the callable accepts keyword arguments (true, false
+    # or :required).
+    def self._define_sequel_method_arg_numbers(callable)
+      optional_args = 0
+      rest = false
+      keyword = false
+      callable.parameters.map(&:first).each do |arg_type, _|
+        case arg_type
+        when :opt
+          optional_args += 1
+        when :rest
+          rest = true
+        when :keyreq
+          keyword = :required
+        when :key, :keyrest
+          keyword ||= true
+        else
+          raise Error, "invalid arg_type passed to _define_sequel_method_arg_numbers: #{arg_type}"
+        end
+      end
+      arity = callable.arity
+      if arity < 0
+        arity = arity.abs - 1
+      end
+      required_args = arity
+      arity -= 1 if keyword == :required
+
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
+
+      [required_args, optional_args, rest, keyword]
+    end
+    private_class_method :_define_sequel_method_arg_numbers
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/model.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+require_relative 'core'
+
+module Sequel
+  # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
+  # model class is backed by a dataset instance, and many dataset methods can be
+  # called directly on the class.  Model datasets return rows as model instances,
+  # which are wrappers around the underlying hash that allow easily updating or
+  # deleting the individual row.
+  #
+  # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
+  # instance, or dataset method defined by a previous plugin and call super to get the default
+  # behavior.  By default, <tt>Sequel::Model</tt> loads two plugins, <tt>Sequel::Model</tt>
+  # (which is itself a plugin) for the base support, and <tt>Sequel::Model::Associations</tt>
+  # for the associations support.
+  #
+  # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
+  # make Sequel not load the associations plugin by default.
+  class Model
+    OPTS = Sequel::OPTS
+
+    # Empty instance methods to create that the user can override.
+    # Just like any other method defined by Sequel, if you override one of these, you should
+    # call +super+ to get the default behavior (while empty by default, they are often overridden
+    # by plugins).  See the {"Model Hooks" guide}[rdoc-ref:doc/model_hooks.rdoc] for
+    # more detail on hooks.
+    HOOKS = [
+      :after_create,
+      :after_destroy,
+      :after_save,
+      :after_update,
+      :after_validation,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_validation
+    ].freeze
+
+    @cache_anonymous_models = true
+    @db = nil
+    @db_schema = nil
+    @dataset = nil
+    @dataset_method_modules = []
+    @default_set_fields_options = {}
+    @overridable_methods_module = nil
+    @fast_pk_lookup_sql = nil
+    @fast_instance_delete_sql = nil
+    @plugins = []
+    @primary_key = :id
+    @raise_on_save_failure = true
+    @raise_on_typecast_failure = false
+    @require_modification = nil
+    @require_valid_table = true
+    @restrict_primary_key = true
+    @setter_methods = nil
+    @simple_pk = nil
+    @simple_table = nil
+    @strict_param_setting = true
+    @typecast_empty_string_to_nil = true
+    @typecast_on_assignment = true
+    @use_transactions = true
+
+    require_relative "model/default_inflections"
+    require_relative "model/inflections"
+    require_relative "model/plugins"
+    require_relative "model/dataset_module"
+    require_relative "model/base"
+    require_relative "model/exceptions"
+    require_relative "model/errors"
+    # :nocov:
+    if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+    # :nocov:
+      require_relative 'model/associations'
+      plugin Model::Associations
+    end
+
+    def_Model(::Sequel)
+
+    # The setter methods (methods ending with =) that are never allowed
+    # to be called automatically via +set+/+update+/+new+/etc.
+    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}.freeze
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/accessed_columns.rb

@@ -0,0 +1,63 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The accessed_columns plugin records which columns have been
+    # accessed for a model instance.  This is useful if you are
+    # looking to remove other columns from being SELECTed by the
+    # dataset that retrieved the instance, which can significantly
+    # improve performance:
+    #
+    #   a = Album[1]
+    #   a.accessed_columns # []
+    #   a.name
+    #   a.accessed_columns # [:name]
+    #   a.artist_id
+    #   a.accessed_columns # [:name, :artist_id]
+    #
+    # Note that this plugin should probably not be used in production,
+    # as it causes a performance hit.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances record accessed columns (called before loading subclasses)
+    #   Sequel::Model.plugin :accessed_columns
+    #
+    #   # Make the Album instances record accessed columns
+    #   Album.plugin :accessed_columns
+    module AccessedColumns
+      module InstanceMethods
+        # Record the column access before retrieving the value.
+        def [](c)
+          (@accessed_columns ||= {})[c] = true unless frozen?
+          super
+        end
+
+        # Clear the accessed columns when saving.
+        def after_save
+          super
+          @accessed_columns = nil
+        end
+
+        # The columns that have been accessed.
+        def accessed_columns
+          @accessed_columns ? @accessed_columns.keys : []
+        end
+
+        # Copy the accessed columns when duping and cloning.
+        def initialize_copy(other)
+          other.instance_variable_set(:@accessed_columns, Hash[@accessed_columns]) if @accessed_columns
+          super
+        end
+
+        private
+
+        # Clear the accessed columns when refreshing.
+        def _refresh(_)
+          @accessed_columns = nil
+          super
+        end
+      end
+    end
+  end
+end