serrano-vk 0.1.0

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

@@ -0,0 +1,158 @@
+# frozen-string-literal: true
+
+require 'delegate'
+
+module Sequel
+  module Plugins
+    # The defaults_setter plugin makes the column getter methods return the default
+    # values for new objects, if the values have not already been set.  Example:
+    #
+    #   # column a default NULL
+    #   # column b default 2
+    #   album = Album.new
+    #   album.a # => nil
+    #   album.b # => 2
+    #   album = Album.new(a: 1, b: 3)
+    #   album.a # => 1
+    #   album.b # => 3
+    #
+    # You can manually set default values as well:
+    #
+    #   Album.default_values[:a] = 4
+    #   Album.new.a # => 4
+    #
+    # You can also provide procs to set default values:
+    #
+    #   Album.default_values[:a] = lambda{Date.today}
+    #   Album.new.a # => Date.today
+    #
+    # If the proc accepts a single argument, it is passed the instance, allowing
+    # default values to depend on instance-specific state:
+    #
+    #   Album.default_values[:a] = lambda{|album| album.b + 1}
+    #   Album.new(b: 10).a # => 11
+    #
+    # By default, default values returned are not cached:
+    #
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # However, you can turn on caching of default values:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # Note that if the cache is turned on, the cached values are stored in
+    # the values hash:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   album = Album.new
+    #   album.values # => {}
+    #   album.a
+    #   album.values # => {:a => Date.today}
+    #
+    # Usage:
+    #
+    #   # Make all model subclass instances set defaults (called before loading subclasses)
+    #   Sequel::Model.plugin :defaults_setter
+    #
+    #   # Make the Album class set defaults
+    #   Album.plugin :defaults_setter
+    module DefaultsSetter
+      # Set the default values based on the model schema. Options:
+      # :cache :: Cache default values returned in the model's values hash.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          set_default_values
+          @cache_default_values = opts[:cache] if opts.has_key?(:cache)
+        end
+      end
+
+      module ClassMethods
+        # The default values to use for this model.  A hash with column symbol
+        # keys and default values.  If the default values respond to +call+, it will be called
+        # to get the value, otherwise the value will be used directly.  You can manually modify
+        # this hash to set specific default values, by default the ones will be parsed from the database.
+        attr_reader :default_values
+
+        Plugins.after_set_dataset(self, :set_default_values)
+
+        Plugins.inherited_instance_variables(self, :@default_values=>:dup, :@cache_default_values=>nil)
+
+        # Whether default values should be cached in the values hash after being retrieved.
+        def cache_default_values?
+          @cache_default_values
+        end
+
+        # Freeze default values when freezing model class
+        def freeze
+          @default_values.freeze
+          super
+        end
+
+        private
+
+        # Parse the cached database schema for this model and set the default values appropriately.
+        def set_default_values
+          h = {}
+          if @db_schema
+            @db_schema.each do |k, v|
+              if v[:callable_default]
+                h[k] = v[:callable_default]
+              elsif !v[:ruby_default].nil?
+                h[k] = convert_default_value(v[:ruby_default])
+              end
+            end
+          end
+          @default_values = h.merge!(@default_values || OPTS)
+        end
+
+        # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
+        # Time/DateTime value.
+        def convert_default_value(v)
+          case v
+          when Sequel::CURRENT_DATE
+            lambda{Date.today}
+          when Sequel::CURRENT_TIMESTAMP
+            lambda{dataset.current_datetime}
+          when Hash, Array
+            v = Marshal.dump(v).freeze
+            lambda{Marshal.load(v)}
+          when Delegator
+            # DelegateClass returns an anonymous case, which cannot be marshalled, so marshal the
+            # underlying object and create a new instance of the class with the unmarshalled object.
+            klass = v.class
+            case o = v.__getobj__
+            when Hash, Array
+              v = Marshal.dump(o).freeze
+              lambda{klass.new(Marshal.load(v))}
+            else
+              v
+            end
+          else
+            v
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Use default value for a new record if values doesn't already contain an entry for it.
+        def [](k)
+          if new? && !values.has_key?(k)
+            v = model.default_values.fetch(k){return}
+            if v.respond_to?(:call)
+              v = if v.respond_to?(:arity) && v.arity == 1
+                v.call(self)
+              else
+                v.call
+              end
+            end
+            values[k] = v if model.cache_default_values?
+            v
+          else
+            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/delay_add_association.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The delay_add_association plugin delays the adding of
+    # associated objects to a new (unsaved) object until after the new
+    # object is saved.  By default, if you attempt to add
+    # associated objects to a new object, Sequel will raise
+    # an error, because you need to have a primary key before
+    # saving the objects.
+    #
+    # When delaying the add of an associated object, the object
+    # will be immediately added to the cached association array.
+    # When saving the current object, it will also attempt to
+    # validate any associated objects, and if the associated objects
+    # are not valid, the current object will also be considered
+    # not valid.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass delay add_association for new objects
+    #   Sequel::Model.plugin :delay_add_association
+    #
+    #   # Make the Album class delay add_association for new objects
+    #   Album.plugin :delay_add_association
+    module DelayAddAssociation
+      # Depend on the validate_associated plugin.
+      def self.apply(mod)
+        mod.plugin :validate_associated
+      end
+
+      module InstanceMethods
+        private
+
+        # Delay the addition of the associated object till after
+        # saving the current object, if the current object is new
+        # and the associated dataset requires a primary key on the
+        # current object.
+        def add_associated_object(opts, o, *args)
+          if opts.dataset_need_primary_key? && new?
+            o = make_add_associated_object(opts, o)
+            delay_validate_associated_object(opts, o)
+            public_send(opts[:name]) << o
+            after_create_hook{super(opts, o, *args)}
+            o
+          else
+            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/deprecated_associations.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The deprecated_associations plugin adds support for
+    # deprecating associations. Attempts to use association
+    # methods and access association metadata for deprecated
+    # associations results in a warning.
+    #
+    #   Album.plugin :deprecated_associations
+    #   Album.many_to_one :artist, deprecated: true
+    #   album = Album[1]
+    #
+    #   # Warnings for all of the following calls
+    #   album.artist
+    #   album.artist_dataset
+    #   album.artist = Artist[2]
+    #   Album.association_reflection(:artist)
+    #   Album.eager(:artist)
+    #   Album.eager_graph(:artist)
+    #   Album.where(artist: Artist[1]).all
+    #
+    # By default, the plugin issues a single warning per
+    # association method or association reflection. See
+    # DeprecatedAssociations.configure for options to make
+    # deprecated association issue warnings for every access,
+    # to include backtraces in warnings, or to raise an
+    # exception instead of warning.
+    #
+    # Note that Model.association_reflections and
+    # Model.all_association_reflections will include deprecated
+    # associations, and accessing the metadata for deprecated
+    # associations through these interfaces not issue warnings.
+    #
+    # Usage:
+    #
+    #   # Make all models support deprecated associations
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :deprecated_associations
+    #
+    #   # Make Album class support deprecated associations
+    #   Album.plugin :deprecated_associations
+    module DeprecatedAssociations
+      # Exception class used for deprecated association use when
+      # raising exceptions instead of emitting warnings.
+      class Access < Sequel::Error; end
+
+      # Configure the deprecated associations plugin. Options:
+      #
+      # backtrace: Print backtrace with warning
+      # deduplicate: Set to false to emit warnings for every
+      #              deprecated association method call/access
+      #              (when not caching associations, this is always false)
+      # raise: Raise Sequel::Plugin::DeprecatedAssociations::Access
+      #        instead of warning
+      def self.configure(model, opts = OPTS)
+        model.instance_exec do
+          (@deprecated_associations_config ||= {}).merge!(opts)
+        end
+      end
+
+      module ClassMethods
+        # Issue a deprecation warning if the association is deprecated.
+        def association_reflection(assoc)
+          ref = super
+          if ref && ref[:deprecated]
+            emit_deprecated_association_warning(ref, nil) do
+              "Access of association reflection for deprecated association: class:#{name} association:#{assoc}"
+            end
+          end
+          ref
+        end
+
+        private
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated and the method name does not start with the
+        # underscore (to avoid not warning twice, once for the public association
+        # method and once for the private association method).
+        def association_module_def(name, opts=OPTS, &block)
+          super
+          if opts[:deprecated] && name[0] != "_"
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              alias_method name, name
+            end
+          end
+          nil
+        end
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated.
+        def association_module_delegate_def(name, opts, &block)
+          super
+          if opts[:deprecated]
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              # :nocov:
+              ruby2_keywords(name) if respond_to?(:ruby2_keywords, true)
+              # :nocov:
+              alias_method(name, name)
+            end
+          end
+          nil
+        end
+
+        # A module to add deprecated association methods to. These methods
+        # handle issuing the deprecation warnings, and call super to get the
+        # default behavior.
+        def deprecated_associations_module
+          return @deprecated_associations_module if defined?(@deprecated_associations_module)
+          @deprecated_associations_module = Module.new
+          include(@deprecated_associations_module)
+          @deprecated_associations_module
+        end
+
+        # Emit a deprecation warning, or raise an exception if the :raise
+        # plugin option was used.
+        def emit_deprecated_association_warning(ref, method)
+          config = @deprecated_associations_config
+
+          raise Access, yield if config[:raise]
+
+          unless config[:deduplicate] == false
+            emit = false
+            ref.send(:cached_fetch, [:deprecated_associations, method]) do
+              emit = true
+            end
+            return unless emit
+          end
+
+          if config[:backtrace]
+            warn yield, caller(2)
+          else
+            warn yield, :uplevel => 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The detect_unnecessary_association_options plugin can detect unnecessary
+    # association options, and either warn or raise if they are detected.
+    # This allows you to find and remove the unnecessary options.
+    # Association options are considered unnecessary if they specify the same
+    # value as Sequel's defaults.
+    #
+    # To detect unnecessary association options, you should load the plugin
+    # into your model base class (e.g. Sequel::Model) before loading your model
+    # classes. Then, after all models have been loaded, you can call the
+    # detect_unnecessary_association_options on each to check for unnecessary
+    # association options. Additionally, if you are calling finalize_associations,
+    # it will automatically check for unnecessary association options.
+    #
+    # A typical usage would be to combine this with the subclasses plugin:
+    #
+    #   Sequel::Model.plugin :detect_unnecessary_association_options
+    #   Sequel::Model.plugin :subclasses
+    #   # load model classes
+    #
+    #   # implicitly check all subclasses when freezing descendants
+    #   Sequel::Model.freeze_descendants
+    #
+    #   # or, if not freezing all descendants
+    #   Sequel::Model.descendants.each(&:detect_unnecessary_association_options)
+    #
+    # By default, the plugin warns for every unnecessary association option.
+    # To raise an error instead, you can pass the <tt>action: :raise</tt> option when loading the
+    # plugin:
+    #
+    #   Sequel::Model.plugin :detect_unnecessary_association_options, action: :raise
+    #
+    # This plugin only detects the most common unnecessary association options, such as:
+    #
+    # * :class (all associations)
+    # * :key and :primary_key (associations without join tables)
+    # * :join_table, :left_key, :right_key, :left_primary_key, :right_primary_key (single join table associations)
+    # * :left_primary_key, :right_primary_key (*_through_many associations)
+    #
+    # Only association types supported by default or supported by a plugin that
+    # ships with Sequel are supported by this plugin. Other association types are
+    # ignored.
+    module DetectUnnecessaryAssociationOptions
+      def self.configure(model, opts={})
+        model.instance_variable_set(:@detect_unnecessary_association_options_action, opts[:action] || :warn)
+      end
+
+      # Raised if the plugin action is to raise and an unnecessary association option
+      # is detected.
+      class UnnecessaryAssociationOption < Sequel::Error
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@detect_unnecessary_association_options_action => nil)
+
+        # Implicitly check for unnecessary association options when finalizing associations.
+        def finalize_associations
+          res = super
+          detect_unnecessary_association_options
+          res
+        end
+
+        # Check for unnecessary association options.
+        def detect_unnecessary_association_options
+          @association_reflections.each_value do |ref|
+            meth = "detect_unnecessary_association_options_#{ref[:type]}"
+            # Expected to call private methods.
+            # Ignore unrecognized association types.
+            # External association types can define the appropriate method to
+            # support their own unnecessary association option checks.
+            if respond_to?(meth, true)
+              # All recognized association types need same class check
+              _detect_unnecessary_association_options_class(ref)
+              send(meth, ref)
+            end
+          end
+
+          nil
+        end
+
+        private
+
+        # Action to take if an unnecessary association option is detected.
+        def unnecessary_association_options_detected(ref, key)
+          if @detect_unnecessary_association_options_action == :raise
+            raise UnnecessaryAssociationOption, "#{ref.inspect} :#{key} option unnecessary"
+          else
+            warn "#{ref.inspect} :#{key} option unnecessary"
+          end
+        end
+
+        # Detect unnecessary :class option.
+        def _detect_unnecessary_association_options_class(ref)
+          return unless ref[:orig_class]
+
+          h = {}
+          name = ref[:name]
+          late_binding_class_option(h, ref.returns_array? ? singularize(name) : name)
+
+          begin
+            default_association_class = constantize(h[:class_name])
+            actual_association_class = ref.associated_class
+          rescue NameError
+            # Do not warn. For the default association class to not be a valid
+            # constant is expected. For the actual association class to not be
+            # a valid constant is not expected and a bug in the association, but
+            # the job of this plugin is not to detect invalid options, only
+            # unnecessary options.
+          else
+            if default_association_class.equal?(actual_association_class)
+              unnecessary_association_options_detected(ref, "class")
+            end
+          end
+        end
+
+        # Detect other unnecessary options. An option is considered unnecessary
+        # if the key was submitted as an association option and the value for
+        # the option is the same as the given value.
+        def _detect_unnecessary_association_options_key_value(ref, key, value)
+          if ref[:orig_opts].has_key?(key) && ref[:orig_opts][key] == value
+            unnecessary_association_options_detected(ref, key)
+          end
+        end
+
+        # Same as _detect_unnecessary_association_options_key_value, but calls
+        # the default_* method on the association reflection to get the default value.
+        def _detect_unnecessary_association_options_key(ref, key)
+          _detect_unnecessary_association_options_key_value(ref, key, ref.send(:"default_#{key}"))
+        end
+
+        def detect_unnecessary_association_options_many_to_one(ref)
+          _detect_unnecessary_association_options_key(ref, :key)
+          _detect_unnecessary_association_options_key_value(ref, :primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_pg_array_to_many detect_unnecessary_association_options_many_to_one
+
+        def detect_unnecessary_association_options_one_to_many(ref)
+          _detect_unnecessary_association_options_key(ref, :key)
+          _detect_unnecessary_association_options_key_value(ref, :primary_key, primary_key)
+        end
+        alias detect_unnecessary_association_options_one_to_one detect_unnecessary_association_options_one_to_many
+        alias detect_unnecessary_association_options_many_to_pg_array detect_unnecessary_association_options_one_to_many
+
+        def detect_unnecessary_association_options_many_to_many(ref)
+          [:join_table, :left_key, :right_key].each do |key|
+            _detect_unnecessary_association_options_key(ref, key)
+          end
+          _detect_unnecessary_association_options_key_value(ref, :left_primary_key, primary_key)
+          _detect_unnecessary_association_options_key_value(ref, :right_primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_one_through_one detect_unnecessary_association_options_many_to_many
+
+        def detect_unnecessary_association_options_many_through_many(ref)
+          _detect_unnecessary_association_options_key_value(ref, :left_primary_key, primary_key)
+          _detect_unnecessary_association_options_key_value(ref, :right_primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_one_through_many detect_unnecessary_association_options_many_through_many
+      end
+    end
+  end
+end