serrano-vk 0.1.0

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

@@ -0,0 +1,61 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The error_splitter plugin automatically splits errors entries related to
+    # multiple columns to have separate error entries, one per column.  For example,
+    # a multiple column uniqueness entry:
+    #
+    #   validates_unique([:artist_id, :name])
+    #
+    # would by default result in errors entries such as:
+    #
+    #   {[:artist_id, :name]=>'is already taken'}
+    #
+    # This plugin transforms those errors into:
+    #
+    #   {:artist_id=>'is already taken', :name=>'is already taken'}
+    #
+    # The main reason to split errors is if you have a list of fields that you
+    # are checking for validation errors.  If you don't split the errors, then:
+    #
+    #   errors.on(:artist_id)
+    #
+    # would not return the uniqueness error.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances split errors (called before loading subclasses)
+    #   Sequel::Model.plugin :error_splitter
+    #
+    #   # Make the Album class split errors
+    #   Album.plugin :error_splitter
+    module ErrorSplitter
+      module InstanceMethods
+        private
+
+        # If the model instance is not valid, split the errors before returning.
+        def _valid?(opts)
+          v = super
+          unless v
+            split_validation_errors(errors)
+          end
+          v
+        end
+
+        # Go through all of the errors entries.  For any that apply to multiple columns,
+        # remove them and add separate error entries, one per column.
+        def split_validation_errors(errors)
+          errors.keys.select{|k| k.is_a?(Array)}.each do |ks|
+            msgs = errors.delete(ks)
+            ks.each do |k|
+              msgs.each do |msg|
+                errors.add(k, msg)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,248 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The finder plugin adds Model.finder for defining optimized finder methods.
+    # There are two ways to use this.  The recommended way is to pass a symbol
+    # that represents a model class method that returns a dataset:
+    #
+    #   def Artist.by_name(name)
+    #     where(name: name)
+    #   end
+    #
+    #   Artist.finder :by_name
+    #
+    # This creates an optimized first_by_name method, which you can call normally:
+    #
+    #   Artist.first_by_name("Joe")
+    #
+    # The alternative way to use this to pass your own block:
+    #
+    #   Artist.finder(name: :first_by_name){|pl, ds| ds.where(name: pl.arg).limit(1)}
+    #
+    # Additionally, there is a Model.prepared_finder method.  This works similarly
+    # to Model.finder, but uses a prepared statement.  This limits the types of
+    # arguments that will be accepted, but can perform better in the database.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support Model.finder
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :finder
+    #
+    #   # Make the Album class support Model.finder
+    #   Album.plugin :finder
+    module Finder
+      FINDER_TYPES = [:first, :all, :each, :get].freeze
+
+      def self.apply(model)
+        model.instance_exec do
+          @finders ||= {}
+          @finder_loaders ||= {}
+        end
+      end
+
+      module ClassMethods
+        # Create an optimized finder method using a dataset placeholder literalizer.
+        # This pre-computes the SQL to use for the query, except for given arguments.
+        #
+        # There are two ways to use this.  The recommended way is to pass a symbol
+        # that represents a model class method that returns a dataset:
+        #
+        #   def Artist.by_name(name)
+        #     where(name: name)
+        #   end
+        #
+        #   Artist.finder :by_name
+        #
+        # This creates an optimized first_by_name method, which you can call normally:
+        #
+        #   Artist.first_by_name("Joe")
+        #
+        # The alternative way to use this to pass your own block:
+        #
+        #   Artist.finder(name: :first_by_name){|pl, ds| ds.where(name: pl.arg).limit(1)}
+        #
+        # Note that if you pass your own block, you are responsible for manually setting
+        # limits if necessary (as shown above).
+        #
+        # Options:
+        # :arity :: When using a symbol method name, this specifies the arity of the method.
+        #           This should be used if if the method accepts an arbitrary number of arguments,
+        #           or the method has default argument values.  Note that if the method is defined
+        #           as a dataset method, the class method Sequel creates accepts an arbitrary number
+        #           of arguments, so you should use this option in that case.  If you want to handle
+        #           multiple possible arities, you need to call the finder method multiple times with
+        #           unique :arity and :name methods each time.
+        # :name :: The name of the method to create.  This must be given if you pass a block.
+        #          If you use a symbol, this defaults to the symbol prefixed by the type.
+        # :mod :: The module in which to create the finder method.  Defaults to the singleton
+        #         class of the model.
+        # :type :: The type of query to run.  Can be :first, :each, :all, or :get, defaults to
+        #          :first.
+        #
+        # Caveats:
+        #
+        # This doesn't handle all possible cases.  For example, if you have a method such as:
+        #
+        #   def Artist.by_name(name)
+        #     name ? where(name: name) : exclude(name: nil)
+        #   end
+        #
+        # Then calling a finder without an argument will not work as you expect.
+        #
+        #   Artist.finder :by_name
+        #   Artist.by_name(nil).first
+        #   # WHERE (name IS NOT NULL)
+        #   Artist.first_by_name(nil)
+        #   # WHERE (name IS NULL)
+        #
+        # See Dataset::PlaceholderLiteralizer for additional caveats. Note that if the model's
+        # dataset does not support placeholder literalizers, you will not be able to use this
+        # method.
+        def finder(meth=OPTS, opts=OPTS, &block)
+          if block
+            raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
+            raise Error, "cannot pass two option hashes to Model.finder" unless opts.equal?(OPTS)
+            opts = meth
+            raise Error, "must provide method name via :name option when passing block to Model.finder" unless meth_name = opts[:name]
+          end
+
+          type = opts.fetch(:type, :first)
+          unless prepare = opts[:prepare]
+            raise Error, ":type option to Model.finder must be :first, :all, :each, or :get" unless FINDER_TYPES.include?(type)
+          end
+          limit1 = type == :first || type == :get
+          meth_name ||= opts[:name] || :"#{type}_#{meth}"
+
+          argn = lambda do |model|
+            if arity = opts[:arity]
+              arity
+            else
+              method = block || model.method(meth)
+              (method.arity < 0 ? method.arity.abs - 1 : method.arity)
+            end
+          end
+
+          loader_proc = if prepare
+            proc do |model|
+              args = prepare_method_args('$a', argn.call(model))
+              ds = if block
+                model.instance_exec(*args, &block)
+              else
+                model.public_send(meth, *args)
+              end
+              ds = ds.limit(1) if limit1
+              model_name = model.name
+              if model_name.to_s.empty?
+                model_name = model.object_id
+              else
+                model_name = model_name.gsub(/\W/, '_')
+              end
+              ds.prepare(type, :"#{model_name}_#{meth_name}")
+            end
+          else
+            proc do |model|
+              n = argn.call(model)
+              block ||= lambda do |pl, model2|
+                args = (0...n).map{pl.arg}
+                ds = model2.public_send(meth, *args)
+                ds = ds.limit(1) if limit1
+                ds
+              end
+
+              model.dataset.placeholder_literalizer_class.loader(model, &block) 
+            end
+          end
+
+          @finder_loaders[meth_name] = loader_proc
+          mod = opts[:mod] || singleton_class
+          if prepare
+            def_prepare_method(mod, meth_name)
+          else
+            def_finder_method(mod, meth_name, type)
+          end
+        end
+
+        def freeze
+          @finder_loaders.freeze
+          @finder_loaders.each_key{|k| finder_for(k)} if @dataset
+          @finders.freeze
+          super
+        end
+
+        # Similar to finder, but uses a prepared statement instead of a placeholder
+        # literalizer. This makes the SQL used static (cannot vary per call), but
+        # allows binding argument values instead of literalizing them into the SQL
+        # query string.
+        #
+        # If a block is used with this method, it is instance_execed by the model,
+        # and should accept the desired number of placeholder arguments.
+        #
+        # The options are the same as the options for finder, with the following
+        # exception:
+        # :type :: Specifies the type of prepared statement to create
+        def prepared_finder(meth=OPTS, opts=OPTS, &block)
+          if block
+            raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
+            meth = meth.merge(:prepare=>true)
+          else
+            opts = opts.merge(:prepare=>true)
+          end
+          finder(meth, opts, &block)
+        end
+
+        Plugins.inherited_instance_variables(self, :@finders=>:dup, :@finder_loaders=>:dup)
+
+        private
+
+        # Define a finder method in the given module with the given method name that
+        # load rows using the finder with the given name.
+        def def_finder_method(mod, meth, type)
+          mod.send(:define_method, meth){|*args, &block| finder_for(meth).public_send(type, *args, &block)}
+        end
+
+        # Define a prepared_finder method in the given module that will call the associated prepared
+        # statement.
+        def def_prepare_method(mod, meth)
+          mod.send(:define_method, meth){|*args, &block| finder_for(meth).call(prepare_method_arg_hash(args), &block)}
+        end
+
+        # Find the finder to use for the give method.  If a finder has not been loaded
+        # for the method, load the finder and set correctly in the finders hash, then
+        # return the finder.
+        def finder_for(meth)
+          unless finder = (frozen? ? @finders[meth] : Sequel.synchronize{@finders[meth]})
+            finder_loader = @finder_loaders.fetch(meth)
+            finder = finder_loader.call(self)
+            Sequel.synchronize{@finders[meth] = finder}
+          end
+          finder
+        end
+
+        # An hash of prepared argument values for the given arguments, with keys
+        # starting at a.  Used by the methods created by prepared_finder.
+        def prepare_method_arg_hash(args)
+          h = {}
+          prepare_method_args('a', args.length).zip(args).each{|k, v| h[k] = v}
+          h
+        end
+
+        # An array of prepared statement argument names, of length n and starting with base.
+        def prepare_method_args(base, n)
+          (0...n).map do
+            s = base.to_sym
+            base = base.next
+            s
+          end
+        end
+
+        # Clear any finders when reseting the instance dataset
+        def reset_instance_dataset
+          Sequel.synchronize{@finders.clear} if @finders && !@finders.frozen?
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,229 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The forbid_lazy_load plugin forbids lazy loading of associations
+    # for objects in cases where the object wasn't loaded with a
+    # method that only returns a single object.
+    #
+    # The main reason for doing this is it makes it easier to detect
+    # N+1 query issues. Note that Sequel also offers a
+    # tactical_eager_loading plugin which will automatically eagerly
+    # load associations for all objects retrived in the same query
+    # if any object would attempt to lazily load an association. That
+    # approach may be simpler if you are trying to prevent N+1 issues,
+    # though it does retain more objects in memory.
+    #
+    # This plugin offers multiple different ways to forbid lazy
+    # loading.  You can forbid lazy loading associations for individual
+    # model instances:
+    #
+    #   obj = Album[1]
+    #   obj.forbid_lazy_load
+    #   obj.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # +forbid_lazy_load+ is automatically called on instances if the
+    # instances are loaded via a method such as Dataset#all,
+    # Dataset#each, and other methods that load multiple instances
+    # at once.  These are the cases where lazily loading associations
+    # for such instances can cause N+1 issues.
+    #
+    #   Album.all.first.artist
+    #   objs.first.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    #   Album.each do |obj|
+    #     obj.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #   end
+    #
+    #   Album[1].artist # no error
+    #
+    #   Album.first.artist # no error
+    #
+    # This behavior of enabling +forbid_lazy_load+ automatically from dataset
+    # methods can be disabled using the plugin's +:allow_by_default+ option.
+    #
+    # You can allow lazy loading associations for an instance that it
+    # was previously forbidden for:
+    # 
+    #   obj = Album.all.first
+    #   obj.allow_lazy_load
+    #   obj.artist # no error
+    #
+    # You can forbid lazy loading associations on a per-call basis,
+    # even if lazy loading of associations is allowed for the instance:
+    #
+    #   obj = Album[1]
+    #   obj.artist(forbid_lazy_load: true)
+    #   # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # This also works for allowing lazy loading associations for a
+    # specific association load even if it is forbidden for the instance:
+    #  
+    #   obj = Album.all.first
+    #   obj.artist(forbid_lazy_load: false)
+    #   # nothing raised
+    #
+    # You can also forbid lazy loading on a per-association basis using the
+    # +:forbid_lazy_load+ association option with a +true+ value:
+    #
+    #   Album.many_to_one :artist, forbid_lazy_load: true
+    #   Album[1].artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # However, you probably don't want to do this as it will forbid any
+    # lazy loading of the association, even if the loading could not
+    # result in an N+1 issue.
+    #
+    # On the flip side, you can allow lazy loading using the 
+    # +:forbid_lazy_load+ association option with a +false+ value:
+    #
+    #   Album.many_to_one :artist, forbid_lazy_load: false
+    #   Album.all.first.artist # no error
+    #
+    # One reason to do this is when using a plugin like static_cache
+    # on the associated model, where a query is not actually issued
+    # when doing a lazy association load.  To make that particular
+    # case easier, this plugin makes Model.finalize_associations
+    # automatically set the association option if the associated
+    # class uses the static_cache plugin.
+    #
+    # Note that even with this plugin, there can still be N+1 issues,
+    # such as:
+    #
+    #   Album.each do |obj| # 1 query for all albums
+    #     Artist[obj.artist_id] # 1 query per album for each artist
+    #   end
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support forbidding lazy load
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :forbid_lazy_load
+    #
+    #   # Make the Album class support forbidding lazy load
+    #   Album.plugin :forbid_lazy_load
+    #
+    #   # Let lazy loading be forbidden by object, but not automatically for any
+    #   # object loaded via dataset.
+    #   Album.plugin :forbid_lazy_load, allow_by_default: true
+    module ForbidLazyLoad
+      def self.apply(model, opts=OPTS)
+        unless opts[:allow_by_default]
+          model.send(:dataset_extend, ForbidByDefault, :create_class_methods=>false)
+        end
+      end
+
+      # Error raised when attempting to lazy load an association when
+      # lazy loading has been forbidden.
+      class Error < StandardError
+      end
+
+      module ClassMethods
+        Plugins.def_dataset_methods(self, :forbid_lazy_load)
+
+        # If the static_cache plugin is used by the associated class for
+        # an association, allow lazy loading that association, since the
+        # lazy association load will use a hash table lookup and not a query.
+        def allow_lazy_load_for_static_cache_associations
+          # :nocov:
+          if defined?(::Sequel::Plugins::StaticCache::ClassMethods)
+          # :nocov:
+            @association_reflections.each_value do |ref|
+              if ref.associated_class.is_a?(::Sequel::Plugins::StaticCache::ClassMethods)
+                ref[:forbid_lazy_load] = false
+              end
+            end
+          end
+        end
+
+        # Allow lazy loading for static cache associations before finalizing.
+        def finalize_associations
+          allow_lazy_load_for_static_cache_associations
+          super
+        end
+      end
+
+      module InstanceMethods
+        # Set this model instance to allow lazy loading of associations.
+        def allow_lazy_load
+          @forbid_lazy_load = false
+          self
+        end
+
+        # Set this model instance to not allow lazy loading of associations.
+        def forbid_lazy_load
+          @forbid_lazy_load = true
+          self
+        end
+
+        private
+
+        # Allow lazy loading for objects returned by singular associations.
+        def _load_associated_object(opts, dynamic_opts)
+          # The implementation that loads these associations does
+          # .all.first, which would result in the object returned being
+          # marked as forbidding lazy load.
+          obj = super
+          obj.allow_lazy_load if obj.is_a?(InstanceMethods)
+          obj
+        end
+
+        # Raise an Error if lazy loading has been forbidden for
+        # the instance, association, or call.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          case dynamic_opts[:forbid_lazy_load]
+          when false
+            # nothing
+          when nil
+            unless dynamic_opts[:reload]
+              case opts[:forbid_lazy_load]
+              when nil
+                raise Error, "lazy loading forbidden for this object (association: #{opts.inspect}, object: #{inspect})" if @forbid_lazy_load
+              when false
+                # nothing
+              else
+                raise Error, "lazy loading forbidden for this association (#{opts.inspect})"
+              end
+            end
+          else
+            raise Error, "lazy loading forbidden for this association method call (association: #{opts.inspect})"
+          end
+
+          super
+        end
+      end
+
+      module ForbidByDefault
+        # Mark model instances retrieved in this call as forbidding lazy loading.
+        def each
+          if row_proc
+            super do |obj|
+              obj.forbid_lazy_load if obj.is_a?(InstanceMethods)
+              yield obj
+            end
+          else
+            super
+          end
+        end
+
+        # Mark model instances retrieved in this call as forbidding lazy loading.
+        def with_sql_each(sql)
+          if row_proc
+            super(sql) do |obj|
+              obj.forbid_lazy_load if obj.is_a?(InstanceMethods)
+              yield obj
+            end
+          else
+            super
+          end
+        end
+
+        # Mark model instances retrieved in this call as allowing lazy loading.
+        def with_sql_first(sql)
+          obj = super
+          obj.allow_lazy_load if obj.is_a?(InstanceMethods)
+          obj
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The force_encoding plugin allows you force specific encodings for all
+    # strings that are used by the model.  When model instances are loaded
+    # from the database, all values in the hash that are strings are
+    # forced to the given encoding.  Whenever you update a model column
+    # attribute, the resulting value is forced to a given encoding if the
+    # value is a string.  There are two ways to specify the encoding.  You
+    # can either do so in the plugin call itself, or via the
+    # forced_encoding class accessor.
+    #
+    # Usage:
+    #
+    #   # Force all strings to be UTF-8 encoded in a all model subclasses
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :force_encoding, 'UTF-8'
+    #
+    #   # Force the encoding for the Album model to UTF-8
+    #   Album.plugin :force_encoding
+    #   Album.forced_encoding = 'UTF-8'
+    module ForceEncoding
+      # Set the forced_encoding based on the value given in the plugin call.
+      # Note that if a the plugin has been previously loaded, any previous
+      # forced encoding is overruled, even if no encoding is given when calling
+      # the plugin.
+      def self.configure(model, encoding=nil)
+        model.forced_encoding = encoding
+      end
+      
+      module ClassMethods
+        # The string encoding to force on a column string values
+        attr_accessor :forced_encoding
+        
+        Plugins.inherited_instance_variables(self, :@forced_encoding=>nil)
+
+        def call(values)
+          o = super
+          o.send(:force_hash_encoding, o.values)
+          o
+        end
+      end
+    
+      module InstanceMethods
+        private
+        
+        # Force the encoding of all string values when setting the instance's values.
+        def _refresh_set_values(values)
+          super(force_hash_encoding(values))
+        end
+        
+        # Force the encoding of all string values when setting the instance's values.
+        def _save_set_values(values)
+          super(force_hash_encoding(values))
+        end
+        
+        # Force the encoding for all string values in the given row hash.
+        def force_hash_encoding(row)
+          if fe = model.forced_encoding
+            row.each_value{|v| v.force_encoding(fe) if v.is_a?(String) && !v.is_a?(Sequel::SQL::Blob)}
+          end
+          row
+        end
+        
+        # Force the encoding of all returned strings to the model's forced_encoding.
+        def typecast_value(column, value)
+          s = super
+          if s.is_a?(String) && !s.is_a?(Sequel::SQL::Blob) && (fe = model.forced_encoding)
+            s = s.dup if s.frozen?
+            s.force_encoding(fe)
+          end
+          s
+        end
+      end
+    end
+  end
+end