serrano-vk 0.1.0

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

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The skip_saving_columms plugin allows skipping specific columns when
+    # saving.  By default, it skips columns that the database schema
+    # indicates are generated columns:
+    #
+    #   # Assume id column, name column, and id2 generated column
+    #   album = Album[1]
+    #   album.id # => 1
+    #   album.name # => 'X'
+    #   album.id2 # => 2
+    #   album.save
+    #   # UPDATE album SET name = 'X' WHERE (id = 1)
+    #
+    # You can override which columns will be skipped:
+    #
+    #   Album.skip_saving_columns = [:name]
+    #   album.save
+    #   # UPDATE album SET id2 = 2 WHERE (id = 1)
+    #
+    # The skipping happens for all usage of Model#save and callers of it (e.g.
+    # Model.create, Model.update).  When using the plugin, the only way to get
+    # it to save a column marked for skipping is to explicitly specify it:
+    #
+    #   album.save(columns: [:name, :id2])
+    #   album.save
+    #   # UPDATE album SET name = 'X', id2 = 2 WHERE (id = 1)
+    #
+    # Usage:
+    #
+    #   # Support skipping saving columns in all Sequel::Model subclasses
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :skip_saving_columns
+    #
+    #   # Support skipping saving columns in the Album class
+    #   Album.plugin :skip_saving_columns
+    module SkipSavingColumns
+      # Setup skipping of the generated columns for a model with an existing dataset.
+      def self.configure(mod)
+        mod.instance_exec do
+          set_skip_saving_generated_columns if @dataset
+        end
+      end
+
+      module ClassMethods
+        # An array of column symbols for columns to skip when saving.
+        attr_reader :skip_saving_columns
+
+        # Over the default array of columns to skip.  Once overridden, future
+        # changes to the class's dataset and future subclasses will automatically
+        # use these overridden columns, instead of introspecting the database schema.
+        def skip_saving_columns=(v) 
+          @_skip_saving_columns_no_override = true
+          @skip_saving_columns = v.dup.freeze
+        end
+
+        Plugins.after_set_dataset(self, :set_skip_saving_generated_columns)
+        Plugins.inherited_instance_variables(self, :@skip_saving_columns=>:dup, :@_skip_saving_columns_no_override=>nil)
+
+        private
+
+        # If the skip saving columns has not been overridden, check the database
+        # schema and automatically skip any generated columns.
+        def set_skip_saving_generated_columns
+          return if @_skip_saving_columns_no_override
+          s = []
+          db_schema.each do |k, v|
+            s << k if v[:generated] 
+          end
+          @skip_saving_columns = s.freeze
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Skip the columns the model has marked to skip when inserting.
+        def _insert_values
+          _save_removed_skipped_columns(Hash[super])
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # all columns.
+        def _save_update_all_columns_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # only changed columns.
+        def _save_update_changed_colums_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Remove any columns the model has marked to skip when saving.
+        def _save_removed_skipped_columns(hash)
+          model.skip_saving_columns.each do |column|
+            hash.delete(column)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The split_values plugin splits the values hash retreived from the
+    # database, and moves keys from the values hash that are not columns
+    # in the model's dataset to a separate hash.  This makes it so the
+    # values hash only stores columns from the model's dataset.
+    #
+    # Among other things, this allows you to save model objects even if
+    # they were retrieved with additional columns, and have equality
+    # comparisons with other instances not care about non-column values.
+    #
+    # Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :split_values
+    #   end
+    #   a1 = Album[1]
+    #   a2 = Album.select_append(Sequel.as(true, :exists))[1]
+    #   a1.name # => 'Album Name'
+    #   a2.name # => 'Album Name'
+    #   a1[:exists] # => nil
+    #   a2[:exists] # => true
+    #   a1 == a2 # => true
+    #   a2.values # => {:id=>1, :name=>'Album Name'}
+    #   a2.save # Works
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances split values
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :split_values
+    #
+    #   # Make the Album class split values
+    #   Album.plugin :split_values
+    module SplitValues
+      module ClassMethods
+        # Split the noncolumn values when creating a new object retrieved from
+        # the database.
+        def call(_)
+          super.split_noncolumn_values
+        end
+      end
+
+      module InstanceMethods
+        # If there isn't an entry in the values hash, but there is a noncolumn_values
+        # hash, look in that hash for the value.
+        def [](k)
+          if  (res = super).nil?
+            @noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values
+          else
+            res
+          end
+        end
+
+        # Remove the key from noncolumn values if it is present there. If it is not
+        # present there, then use the default behavior of removing it from values.
+        def remove_key!(key)
+          if @noncolumn_values && @noncolumn_values.key?(key)
+            @noncolumn_values.delete(key)
+          else
+            super
+          end
+        end
+
+        # Check all entries in the values hash.  If any of the keys are not columns,
+        # move the entry into the noncolumn_values hash.
+        def split_noncolumn_values
+          cols = (@values.keys - columns)
+          return self if cols.empty?
+
+          nc = @noncolumn_values ||= {}
+          vals = @values
+          cols.each{|k| nc[k] = vals.delete(k)}
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The sql_comments plugin will automatically use SQL comments on
+    # queries for the model it is loaded into.  These comments will
+    # show the related model, what type of method was called, and
+    # the method name (or association name for queries to load
+    # associations):
+    #
+    #   album = Album[1]
+    #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    #   # -- model:Album,method_type:class,method:[]
+    #
+    #   album.update(name: 'A')
+    #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    #   # -- model:Album,method_type:instance,method:update
+    #
+    #   album.artist
+    #   # SELECT * FROM artists WHERE (artists.id = 1)
+    #   # -- model:Album,method_type:association_load,association:artist
+    #
+    #   Album.eager(:artists).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM artists WHERE (artists.id IN (1))
+    #   # -- model:Album,method_type:association_eager_load,association:artist
+    #   
+    #   Album.where(id: 1).delete
+    #   # DELETE FROM albums WHERE (id = 1)
+    #   # -- model:Album,method_type:dataset,method:delete
+    #
+    # This plugin automatically supports the class, instance, and dataset
+    # methods are are supported by default in Sequel::Model.  To support
+    # custom class, instance, and dataset methods, such as those added by
+    # other plugins, you can use the appropriate <tt>sql_comments_*_methods</tt>
+    # class method:
+    #
+    #   Album.sql_comments_class_methods :first_by_name # example from finder plugin, with :mod option
+    #   Album.sql_comments_instance_methods :lazy_attribute_lookup # lazy_attributes plugin
+    #   Album.sql_comments_dataset_methods :to_csv # csv_serializer plugin
+    #
+    # In order for the sql_comments plugin to work, the sql_comments
+    # Database extension must be loaded into the model's database, so
+    # loading the plugin does this automatically.
+    #
+    # Note that in order to make sure SQL comments are included, some
+    # optimizations are disabled if this plugin is loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support automatic SQL comments
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :sql_comments
+    #
+    #   # Make the Album class support automatic SQL comments
+    #   Album.plugin :sql_comments
+    module SqlComments
+      # Define a method +meth+ on the given module +mod+ that will use automatic
+      # SQL comments with the given model, method_type, and method.
+      def self.def_sql_commend_method(mod, model, method_type, meth)
+        mod.send(:define_method, meth) do |*a, &block|
+          model.db.with_comments(:model=>model, :method_type=>method_type, :method=>meth) do
+            super(*a, &block)
+          end
+        end
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if mod.respond_to?(:ruby2_keywords, true)
+        # :nocov:
+      end
+
+      def self.apply(model)
+        model.db.extension(:sql_comments)
+      end
+
+      def self.configure(model)
+        model.send(:reset_fast_pk_lookup_sql)
+      end
+
+      module ClassMethods
+        # Use automatic SQL comments for the given class methods.
+        def sql_comments_class_methods(*meths)
+          _sql_comments_methods(singleton_class, :class, meths)
+        end
+
+        # Use automatic SQL comments for the given instance methods.
+        def sql_comments_instance_methods(*meths)
+          _sql_comments_methods(self, :instance, meths)
+        end
+
+        # Use automatic SQL comments for the given dataset methods.
+        def sql_comments_dataset_methods(*meths)
+          unless @_sql_comments_dataset_module
+            dataset_module(@_sql_comments_dataset_module = Sequel.set_temp_name(Module.new){"#{name}::@_sql_comments_dataset_module"})
+          end
+          _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
+        end
+
+        [:[], :create, :find, :find_or_create, :with_pk, :with_pk!].each do |meth|
+          define_method(meth) do |*a, &block|
+            db.with_comments(:model=>self, :method_type=>:class, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Don't optimize the fast PK lookups, as it uses static SQL that
+        # won't support the SQL comments.
+        def reset_fast_pk_lookup_sql
+          @fast_pk_lookup_sql = @fast_instance_delete_sql = nil
+        end
+
+        # Define automatic SQL comment methods in +mod+ for each method in +meths+,
+        # with the given +method_type+.
+        def _sql_comments_methods(mod, method_type, meths)
+          meths.each do |meth|
+            SqlComments.def_sql_commend_method(mod, self, method_type, meth)
+          end
+        end
+      end
+
+      module InstanceMethods
+        [:delete, :destroy, :lock!, :refresh, :save, :save_changes, :update, :update_fields].each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:instance, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Do not use a placeholder loader for associations.
+        def _associated_object_loader(opts, dynamic_opts)
+          nil
+        end
+
+        # Use SQL comments on normal association load queries, showing they are association loads.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          db.with_comments(:model=>model, :method_type=>:association_load, :association=>opts[:name]) do
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        Dataset::ACTION_METHODS.each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:dataset, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Add the association name as part of the eager load data, so
+        # perform_eager_load has access to it.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          res = super
+          
+          reflections.each do |r|
+            res[r[:eager_loader]][:association] = r[:name]
+          end
+
+          res
+        end
+
+        # Use SQL comments on eager load queries, showing they are eager loads.
+        def perform_eager_load(loader, eo)
+          db.with_comments(:model=>model, :method_type=>:association_eager_load, :method=>nil, :association=>eo[:association]) do
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,315 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The static_cache plugin is designed for models that are not modified at all
+    # in production use cases, or at least where modifications to them would usually
+    # coincide with an application restart.  When loaded into a model class, it 
+    # retrieves all rows in the database and statically caches a ruby array and hash
+    # keyed on primary key containing all of the model instances.  All of these instances
+    # are frozen so they won't be modified unexpectedly, and before hooks disallow
+    # saving or destroying instances.
+    #
+    # You can use the frozen: false option to have this plugin return unfrozen
+    # instances.  This is slower as it requires creating new objects, but it allows
+    # you to make changes to the object and save them.  If you set the option to false,
+    # you are responsible for updating the cache manually (the pg_static_cache_updater
+    # extension can handle this automatically).  Note that it is not safe to use the
+    # frozen: false option if you are mutating column values directly.  If you are
+    # mutating column values, you should also override Model.call to dup each mutable
+    # column value to ensure it is not shared by other instances.
+    #
+    # The caches this plugin creates are used for the following things:
+    #
+    # * Primary key lookups (e.g. Model[1])
+    # * Model.all
+    # * Model.each
+    # * Model.first (without block, only supporting no arguments or single integer argument)
+    # * Model.count (without an argument or block)
+    # * Model.map
+    # * Model.as_hash
+    # * Model.to_hash
+    # * Model.to_hash_groups
+    #
+    # Usage:
+    #
+    #   # Cache the AlbumType class statically, disallowing any changes.
+    #   AlbumType.plugin :static_cache
+    #
+    #   # Cache the AlbumType class statically, but return unfrozen instances
+    #   # that can be modified.
+    #   AlbumType.plugin :static_cache, frozen: false
+    #
+    # If you would like the speed benefits of keeping frozen: true but still need
+    # to occasionally update objects, you can side-step the before_ hooks by
+    # overriding the class method +static_cache_allow_modifications?+ to return true:
+    #
+    #   class Model
+    #     plugin :static_cache
+    #
+    #     def self.static_cache_allow_modifications?
+    #       true
+    #     end
+    #   end
+    #
+    # Now if you +#dup+ a Model object (the resulting object is not frozen), you
+    # will be able to update and save the duplicate.
+    # Note the caveats around your responsibility to update the cache still applies.
+    # You can update the cache via `.load_cache` method.
+    module StaticCache
+      # Populate the static caches when loading the plugin. Options:
+      # :frozen :: Whether retrieved model objects are frozen.  The default is true,
+      #            for better performance as the shared frozen objects can be used
+      #            directly.  If set to false, new instances are created.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          @static_cache_frozen = opts.fetch(:frozen, true)
+          if @static_cache_frozen && defined?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods) && is_a?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods)
+            extend ForbidLazyLoadClassMethods
+          end
+          load_cache
+        end
+      end
+
+      module ClassMethods
+        # A frozen ruby hash holding all of the model's frozen instances, keyed by frozen primary key.
+        attr_reader :cache
+
+        # An array of all of the model's instances, without issuing a database
+        # query. If a block is given, yields each instance to the block.
+        def all(&block)
+          array = @static_cache_frozen ? @all.dup : to_a
+          array.each(&block) if block
+          array
+        end
+
+        # If a block is given, multiple arguments are given, or a single
+        # non-Integer argument is given, performs the default behavior of
+        # issuing a database query.  Otherwise, uses the cached values
+        # to return either the first cached instance (no arguments) or an
+        # array containing the number of instances specified (single integer
+        # argument).
+        def first(*args)
+          if defined?(yield) || args.length > 1 || (args.length == 1 && !args[0].is_a?(Integer))
+            super
+          else
+            @all.first(*args)
+          end
+        end
+
+        # Get the number of records in the cache, without issuing a database query.
+        def count(*a, &block)
+          if a.empty? && !block
+            @all.size
+          else
+            super
+          end
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def cache_get_pk(pk)
+          static_cache_object(cache[pk])
+        end
+
+        # Yield each of the model's frozen instances to the block, without issuing a database
+        # query.
+        def each(&block)
+          if @static_cache_frozen
+            @all.each(&block)
+          else
+            @all.each{|o| yield(static_cache_object(o))}
+          end
+        end
+
+        # Use the cache instead of a query to get the results.
+        def map(column=nil, &block)
+          if column
+            raise(Error, "Cannot provide both column and block to map") if block
+            if column.is_a?(Array)
+              @all.map{|r| r.values.values_at(*column)}
+            else
+              @all.map{|r| r[column]}
+            end
+          elsif @static_cache_frozen
+            @all.map(&block)
+          elsif block
+            @all.map{|o| yield(static_cache_object(o))}
+          else
+            all.map
+          end
+        end
+
+        Plugins.after_set_dataset(self, :load_cache)
+        Plugins.inherited_instance_variables(self, :@static_cache_frozen=>nil)
+
+        # Use the cache instead of a query to get the results.
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          if key_column.nil? && value_column.nil?
+            if @static_cache_frozen && !opts[:hash]
+              return Hash[cache]
+            else
+              key_column = primary_key
+            end
+          end
+
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+              else
+                @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+              else
+                @all.each{|r| h[r[key_column]] = r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
+          else
+            @all.each{|r| h[r[key_column]] = static_cache_object(r)}
+          end
+          h
+        end
+
+        # Use the cache instead of a query to get the results.
+        def as_set(column)
+          set = Set.new
+
+          if column.is_a?(Array)
+            @all.each{|r| set.add(r.values.values_at(*column))}
+          else
+            @all.each{|r| set.add(r[column])}
+          end
+
+          set
+        end
+
+        # Alias of as_hash for backwards compatibility.
+        def to_hash(*a)
+          as_hash(*a)
+        end
+
+        # Use the cache instead of a query to get the results
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                @all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r.values.values_at(*value_column)}
+              else
+                @all.each{|r| (h[r[key_column]] ||= []) << r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                @all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r[value_column]}
+              else
+                @all.each{|r| (h[r[key_column]] ||= []) << r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            @all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << static_cache_object(r)}
+          else
+            @all.each{|r| (h[r[key_column]] ||= []) << static_cache_object(r)}
+          end
+          h
+        end
+
+        # Ask whether modifications to this class are allowed.
+        def static_cache_allow_modifications?
+          !@static_cache_frozen
+        end
+
+        # Reload the cache for this model by retrieving all of the instances in the dataset
+        # freezing them, and populating the cached array and hash.
+        def load_cache
+          @all = load_static_cache_rows
+          h = {}
+          @all.each do |o|
+            o.errors.freeze
+            h[o.pk.freeze] = o.freeze
+          end
+          @cache = h.freeze
+        end
+
+        private
+
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def primary_key_lookup(pk)
+          static_cache_object(cache[pk])
+        end
+
+        # If frozen: false is not used, just return the argument. Otherwise,
+        # create a new instance with the arguments values if the argument is
+        # not nil.
+        def static_cache_object(o)
+          if @static_cache_frozen
+            o
+          elsif o
+            call(Hash[o.values])
+          end
+        end
+      end
+
+      module ForbidLazyLoadClassMethods
+        # Do not forbid lazy loading for single object retrieval.
+        def cache_get_pk(pk)
+          primary_key_lookup(pk)
+        end
+
+        # Use static cache to return first arguments.
+        def first(*args)
+          if !defined?(yield) && args.empty?
+            if o = @all.first
+              _static_cache_frozen_copy(o)
+            end
+          else
+            super
+          end
+        end
+
+        private
+
+        # Return a frozen copy of the object that does not have lazy loading
+        # forbidden.
+        def _static_cache_frozen_copy(o)
+          o = call(Hash[o.values])
+          o.errors.freeze
+          o.freeze
+        end
+
+        # Do not forbid lazy loading for single object retrieval.
+        def primary_key_lookup(pk)
+          if o = cache[pk]
+            _static_cache_frozen_copy(o)
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Disallowing destroying the object unless the frozen: false option was used.
+        def before_destroy
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
+          super
+        end
+
+        # Disallowing saving the object unless the frozen: false option was used.
+        def before_save
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
+          super
+        end
+      end
+    end
+  end
+end