serrano-vk 0.1.0

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

@@ -0,0 +1,124 @@
+# frozen-string-literal: true
+
+require 'active_model'
+module Sequel
+  module Plugins
+    # The active_model plugin makes Sequel::Model objects
+    # pass the ActiveModel::Lint tests, which should
+    # hopefully mean full ActiveModel compliance.  This should
+    # allow the full support of Sequel::Model objects in Rails 3+.
+    # This plugin requires active_model in order to use
+    # ActiveModel::Naming.
+    # 
+    # Usage:
+    #
+    #   # Make all subclasses active_model compliant (called before loading subclasses)
+    #   Sequel::Model.plugin :active_model
+    #
+    #   # Make the Album class active_model compliant
+    #   Album.plugin :active_model
+    module ActiveModel
+      # ActiveModel compliant error class
+      class Errors < Sequel::Model::Errors
+        # Add autovivification so that #[] always returns an array.
+        def [](k)
+          fetch(k){self[k] = []}
+        end
+      end
+
+      module ClassMethods
+        include ::ActiveModel::Naming
+
+        # Cache model_name and to_partial path value before freezing.
+        def freeze
+          model_name
+          _to_partial_path
+
+          super
+        end
+        
+        # Class level cache for to_partial_path.
+        def _to_partial_path
+          @_to_partial_path ||= "#{underscore(pluralize(to_s))}/#{underscore(demodulize(to_s))}".freeze
+        end
+      end
+
+      module InstanceMethods
+        # Record that an object was destroyed, for later use by
+        # destroyed?
+        def after_destroy
+          super
+          @destroyed = true
+        end
+
+        # Return ::ActiveModel::Name instance for the class.
+        def model_name
+          model.model_name
+        end
+
+        # False if the object is new? or has been destroyed, true otherwise.
+        def persisted?
+          return false if new?
+          return false if defined?(@destroyed)
+
+          if defined?(@rollback_checker)
+            if @rollback_checker.call
+              return false
+            end
+          end
+          
+          true
+        end
+        
+        # An array of primary key values, or nil if the object is not persisted.
+        def to_key
+          if primary_key.is_a?(Symbol)
+            [pk] if pk
+          else
+            pk if pk.all?
+          end
+        end
+
+        # With the active_model plugin, Sequel model objects are already
+        # compliant, so this returns self.
+        def to_model
+          self
+        end
+        
+        # An string representing the object's primary key.  For composite
+        # primary keys, joins them with to_param_joiner.
+        def to_param
+          if persisted? and k = to_key
+            k.join(to_param_joiner)
+          end
+        end
+
+        # Returns a string identifying the path associated with the object.
+        def to_partial_path
+          model._to_partial_path
+        end
+        
+        private
+
+        # For new objects, add a rollback checker to check if the transaction
+        # in which this instance is created is rolled back.
+        def _save(opts)
+          if new? && db.in_transaction?(opts)
+            @rollback_checker = db.rollback_checker(opts)
+          end
+          super
+        end
+
+        # Use ActiveModel compliant errors class.
+        def errors_class
+          Errors
+        end
+        
+        # The string to use to join composite primary key param strings.
+        def to_param_joiner
+          '-'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # Adds an after_initialize hook to models, called after initializing
+    # both new objects and ones loaded from the database.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support the after_initialize hook
+    #   Sequel::Model.plugin :after_initialize
+    #
+    #   # Make the Album class support the after_initialize hook
+    #   Album.plugin :after_initialize
+    module AfterInitialize
+      module ClassMethods
+        # Call after_initialize for model objects loaded from the database.
+        def call(_)
+          v = super
+          v.after_initialize
+          v
+        end
+      end
+
+      module InstanceMethods
+        # Call after_initialize for new model objects.
+        def initialize(h={})
+          super
+          after_initialize
+        end
+       
+        # An empty after_initialize hook, so that plugins that use this
+        # can always call super to get the default behavior.
+        def after_initialize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_dependencies plugin allows you do easily set up before and/or after destroy hooks
+    # for destroying, deleting, or nullifying associated model objects.  The following
+    # association types support the following dependency actions:
+    # 
+    # :many_to_many :: :nullify (removes all related entries in join table)
+    # :many_to_one :: :delete, :destroy
+    # :one_to_many, one_to_one :: :delete, :destroy, :nullify (sets foreign key to NULL for all associated objects)
+    #
+    # This plugin works directly with the association datasets and does not use any cached association values.
+    # The :delete action will delete all associated objects from the database in a single SQL call.
+    # The :destroy action will load each associated object from the database and call the destroy method on it.
+    #
+    # To set up an association dependency, you must provide a hash with association name symbols
+    # and dependency action values.  You can provide the hash to the plugin call itself or
+    # to the add_association_dependencies method:
+    #
+    #   Business.plugin :association_dependencies, address: :delete
+    #   # or:
+    #   Artist.plugin :association_dependencies
+    #   Artist.add_association_dependencies albums: :destroy, reviews: :delete, tags: :nullify
+    module AssociationDependencies
+      # Mapping of association types to when the dependency calls should be made (either
+      # :before for in before_destroy or :after for in after_destroy)
+      ASSOCIATION_MAPPING = {:one_to_many=>:before, :many_to_one=>:after, :many_to_many=>:before, :one_to_one=>:before}.freeze
+
+      # The valid dependence actions
+      DEPENDENCE_ACTIONS = [:delete, :destroy, :nullify].freeze
+
+      # Initialize the association_dependencies hash for this model.
+      def self.apply(model, hash=OPTS)
+        model.instance_exec{@association_dependencies = {:before_delete=>[], :before_destroy=>[], :before_nullify=>[], :after_delete=>[], :after_destroy=>[]}}
+      end
+
+      # Call add_association_dependencies with any dependencies given in the plugin call.
+      def self.configure(model, hash=OPTS)
+        model.add_association_dependencies(hash) unless hash.empty?
+      end
+
+      module ClassMethods
+        # A hash specifying the association dependencies for each model.  The keys
+        # are symbols indicating the type of action and when it should be executed
+        # (e.g. :before_delete).  Values are an array of method symbols.
+        # For before_nullify, the symbols are remove_all_association methods.  For other
+        # types, the symbols are association_dataset methods, on which delete or
+        # destroy is called.
+        attr_reader :association_dependencies
+
+        # Add association dependencies to this model.  The hash should have association name
+        # symbol keys and dependency action symbol values (e.g. albums: :destroy).
+        def add_association_dependencies(hash)
+          hash.each do |association, action|
+            raise(Error, "Nonexistent association: #{association}") unless r = association_reflection(association)
+            type = r[:type]
+            raise(Error, "Invalid dependence action type: association: #{association}, dependence action: #{action}") unless DEPENDENCE_ACTIONS.include?(action)
+            raise(Error, "Invalid association type: association: #{association}, type: #{type}") unless time = ASSOCIATION_MAPPING[type]
+            association_dependencies[:"#{time}_#{action}"] << if action == :nullify
+              case type
+              when :one_to_many , :many_to_many
+                [r[:remove_all_method]]
+              when :one_to_one
+                [r[:setter_method], nil]
+              else
+                raise(Error, "Can't nullify many_to_one associated objects: association: #{association}")
+              end
+            else
+              raise(Error, "Can only nullify many_to_many associations: association: #{association}") if type == :many_to_many
+              r[:dataset_method]
+            end
+          end
+        end
+
+        # Freeze association dependencies when freezing model class.
+        def freeze
+          @association_dependencies.freeze.each_value(&:freeze)
+
+          super
+        end
+
+        Plugins.inherited_instance_variables(self, :@association_dependencies=>:hash_dup)
+      end
+
+      module InstanceMethods
+        # Run the delete and destroy association dependency actions for
+        # many_to_one associations.
+        def after_destroy
+          super
+          model.association_dependencies[:after_delete].each{|m| public_send(m).delete}
+          model.association_dependencies[:after_destroy].each{|m| public_send(m).destroy}
+        end
+
+        # Run the delete, destroy, and nullify association dependency actions for
+        # *_to_many associations.
+        def before_destroy
+          model.association_dependencies[:before_delete].each{|m| public_send(m).delete}
+          model.association_dependencies[:before_destroy].each{|m| public_send(m).destroy}
+          model.association_dependencies[:before_nullify].each{|args| public_send(*args)}
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_lazy_eager_option plugin supports passing
+    # an +:eager+ option to an association method.  If the related
+    # association is already cached, the cached version will be
+    # returned.  If the association is not already cached, it will
+    # be loaded, and the value of the +:eager+ option will be used
+    # to perform an eager load of the given associations.
+    # the plural versions.
+    #
+    # With Sequel's default behavior, you can already perform an
+    # eager load when lazy loading using a block:
+    #
+    #   obj.association{|ds| ds.eager(:nested_association)}
+    #
+    # However, this will ignore any cached version.  In more
+    # complex software, the association may already be cached
+    # and have the nested association cached inside of it, and
+    # using this callback approach then requires 2 unnecessary
+    # queries. This plugin will not perform any queries if the
+    # association is already cached, preventing duplicate work.
+    # However, you should make sure that an already loaded
+    # association has the nested association already eagerly
+    # loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support the :eager association
+    #   # method option (called before loading subclasses)
+    #   Sequel::Model.plugin :association_lazy_eager_option
+    #
+    #   # Make the Album class support the :eager association
+    #   # method option
+    #   Album.plugin :association_lazy_eager_option
+    module AssociationLazyEagerOption
+      module InstanceMethods
+        private
+
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = super
+
+          if eager = dynamic_opts[:eager]
+            ds = ds.eager(eager)
+          end
+
+          ds
+        end
+        
+        # A placeholder literalizer that can be used to load the association, or nil to not use one.
+        def _associated_object_loader(opts, dynamic_opts)
+          return if dynamic_opts[:eager]
+          super
+        end
+
+        # Whether to use a simple primary key lookup on the associated class when loading.
+        def load_with_primary_key_lookup?(opts, dynamic_opts)
+          return false if dynamic_opts[:eager]
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_multi_add_remove plugin allows adding, removing and setting
+    # multiple associated objects in a single method call.
+    # By default Sequel::Model defines singular <tt>add_*</tt> and <tt>remove_*</tt>
+    # methods that operate on a single associated object, this adds plural forms
+    # that operate on multiple associated objects. Example:
+    #
+    #   artist.albums # => [album1]
+    #   artist.add_albums([album2, album3])
+    #   artist.albums # => [album1, album2, album3]
+    #   artist.remove_albums([album3, album1])
+    #   artist.albums # => [album2]
+    #   artist.albums = [album2, album3]
+    #   artist.albums # => [album2, album3]
+    #
+    # It can handle all situations that the normal singular methods handle, but there is
+    # no attempt to optimize behavior, so using these methods will not improve performance.
+    #
+    # The add/remove/set methods defined by this plugin use a transaction,
+    # so if one add/remove/set fails and raises an exception, all adds/removes/set
+    # will be rolled back. If you are using database sharding and want to save
+    # to a specific shard, call Model#set_server to set the server for this instance,
+    # as the transaction will be opened on that server.
+    #
+    # You can customize the method names used for adding/removing multiple associated
+    # objects using the :multi_add_method and :multi_remove_method association options.
+    #
+    # Usage:
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for all model subclass instances (called before loading subclasses):
+    #   Sequel::Model.plugin :association_multi_add_remove
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for Album instances (called before defining associations in the class):
+    #   Album.plugin :association_multi_add_remove
+    module AssociationMultiAddRemove
+      module ClassMethods
+        private
+
+        # Define the methods use to add/remove/set multiple associated objects
+        # in a single method call.
+        def def_association_instance_methods(opts)
+          super
+
+          if opts[:adder]
+            add_method = opts[:add_method]
+            multi_add_method = opts[:multi_add_method] || :"add_#{opts[:name]}"
+            multi_add_method = nil if add_method == multi_add_method
+            if multi_add_method
+              association_module_def(multi_add_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(add_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if opts[:remover]
+            remove_method = opts[:remove_method]
+            multi_remove_method = opts[:multi_remove_method] || :"remove_#{opts[:name]}"
+            multi_remove_method = nil if remove_method == multi_remove_method
+            if multi_remove_method
+              association_module_def(multi_remove_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(remove_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if multi_add_method && multi_remove_method
+            association_module_def(:"#{opts[:name]}=", opts) do |objs, *args|
+              db.transaction(:server=>@server) do
+                existing_objs = send(opts.association_method)
+                send(multi_remove_method, (existing_objs - objs), *args)
+                send(multi_add_method, (objs - existing_objs), *args)
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end