serrano-vk 0.1.0

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

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # Sequel's built-in hook_class_methods plugin is designed for backwards
+    # compatibility.  Its use is not encouraged, it is recommended to use
+    # instance methods and super instead of this plugin.  This plugin allows
+    # calling class methods with blocks to define hooks:
+    #
+    #   # Block only, can cause duplicate hooks if code is reloaded
+    #   before_save{self.created_at = Time.now}
+    #   # Block with tag, safe for reloading
+    #   before_save(:set_created_at){self.created_at = Time.now}
+    #   # Tag only, safe for reloading, calls instance method
+    #   before_save(:set_created_at)
+    #
+    # Pretty much anything you can do with a hook class method, you can also
+    # do with an instance method instead (making sure to call super), which is
+    # the recommended way to add hooks in Sequel:
+    #
+    #    def before_save
+    #      super
+    #      self.created_at = Time.now
+    #    end
+    #
+    # Usage:
+    #
+    #   # Allow use of hook class methods in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :hook_class_methods
+    #
+    #   # Allow the use of hook class methods in the Album class
+    #   Album.plugin :hook_class_methods
+    module HookClassMethods
+      # Set up the hooks instance variable in the model.
+      def self.apply(model)
+        hooks = model.instance_variable_set(:@hooks, {})
+        Model::HOOKS.each{|h| hooks[h] = []}
+      end
+
+      module ClassMethods
+        Model::HOOKS.each do |h|
+          class_eval(<<-END, __FILE__, __LINE__ + 1)
+            def #{h}(method = nil, &block)
+              add_hook(:#{h}, method, &block)
+            end
+          END
+        end
+
+        # Freeze hooks when freezing model class.
+        def freeze
+          @hooks.freeze.each_value(&:freeze)
+          super
+        end
+    
+        # Returns true if there are any hook blocks for the given hook.
+        def has_hooks?(hook)
+          !@hooks[hook].empty?
+        end
+    
+        # Yield every block related to the given hook.
+        def hook_blocks(hook)
+          # SEQUEL6: Remove
+          Sequel::Deprecation.deprecate("The hook_blocks class method in the hook_class_methods plugin is deprecated and will be removed in Sequel 6.")
+          @hooks[hook].each{|_,v,_| yield v}
+        end
+
+        # Yield every method related to the given hook.
+        def hook_methods_for(hook)
+          @hooks[hook].each{|_,_,m| yield m}
+        end
+
+        Plugins.inherited_instance_variables(self, :@hooks=>:hash_dup)
+    
+        private
+    
+        # Add a hook block to the list of hook methods.
+        # If a non-nil tag is given and it already is in the list of hooks,
+        # replace it with the new block.
+        def add_hook(hook, tag, &block)
+          unless block
+            (raise Error, 'No hook method specified') unless tag
+            # Allow calling private hook methods
+            block = proc {send(tag)}
+          end
+
+          h = @hooks[hook]
+
+          if tag && (old = h.find{|x| x[0] == tag})
+            old[1] = block
+            Plugins.def_sequel_method(self, old[2], 0, &block)
+          else
+            meth = Plugins.def_sequel_method(self, "validation_class_methods_#{hook}", 0, &block)
+            if hook.to_s =~ /^before/
+              h.unshift([tag, block, meth])
+            else
+              h << [tag, block, meth]
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        # hook methods are private
+        [:before_create, :before_update, :before_validation, :before_save, :before_destroy].each{|h| class_eval("def #{h}; model.hook_methods_for(:#{h}){|m| send(m)}; super end", __FILE__, __LINE__)}
+
+        [:after_create, :after_update, :after_validation, :after_save, :after_destroy].each{|h| class_eval("def #{h}; super; model.hook_methods_for(:#{h}){|m| send(m)}; end", __FILE__, __LINE__)}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # InputTransformer is a plugin that allows generic transformations
+    # of input values in model column setters.  Example:
+    #
+    #   Album.plugin :input_transformer
+    #   Album.add_input_transformer(:reverser){|v| v.is_a?(String) ? v.reverse : v}
+    #   album = Album.new(name: 'foo')
+    #   album.name # => 'oof'
+    #
+    # You can specifically set some columns to skip some input
+    # input transformers:
+    #
+    #   Album.skip_input_transformer(:reverser, :foo)
+    #   Album.new(foo: 'bar').foo # => 'bar'
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances support input transformers (called before loading subclasses)
+    #   Sequel::Model.plugin :input_transformer
+    #
+    #   # Make the Album class support input transformers 
+    #   Album.plugin :input_transformer
+    module InputTransformer
+      def self.apply(model, *, &_)
+        model.instance_exec do
+          @input_transformers = {}
+          @skip_input_transformer_columns = {}
+        end
+      end
+
+      # If an input transformer is given in the plugin call,
+      # add it as a transformer
+      def self.configure(model, transformer_name=nil, &block)
+        model.add_input_transformer(transformer_name, &block) if transformer_name || block
+      end
+
+      module ClassMethods
+        # Hash of input transformer name symbols to transformer callables.
+        attr_reader :input_transformers
+
+        # The order in which to call the input transformers. For backwards compatibility only.
+        def input_transformer_order
+          input_transformers.keys.reverse
+        end
+
+        Plugins.inherited_instance_variables(self, :@skip_input_transformer_columns=>:hash_dup, :@input_transformers=>:dup)
+
+        # Add an input transformer to this model.
+        def add_input_transformer(transformer_name, &block)
+          raise(Error, 'must provide both transformer name and block when adding input transformer') unless transformer_name && block
+          @input_transformers[transformer_name] = block
+          @skip_input_transformer_columns[transformer_name] = []
+        end
+
+        # Freeze input transformers when freezing model class
+        def freeze
+          @input_transformers.freeze
+          @skip_input_transformer_columns.freeze.each_value(&:freeze)
+
+          super
+        end
+
+        # Set columns that the transformer should skip.
+        def skip_input_transformer(transformer_name, *columns)
+          @skip_input_transformer_columns[transformer_name].concat(columns).uniq!
+        end
+
+        # Return true if the transformer should not be called for the given column.
+        def skip_input_transformer?(transformer_name, column)
+          @skip_input_transformer_columns[transformer_name].include?(column)
+        end
+      end
+
+      module InstanceMethods
+        # Transform the input using all of the transformers, except those explicitly
+        # skipped, before setting the value in the model object.
+        def []=(k, v)
+          model.input_transformers.reverse_each do |name, transformer|
+            v = transformer.call(v) unless model.skip_input_transformer?(name, k)
+          end
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The insert_conflict plugin allows handling conflicts due to unique
+    # constraints when saving new model instance, using the INSERT ON CONFLICT
+    # support in PostgreSQL 9.5+ and SQLite 3.24.0+. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :insert_conflict
+    #   end
+    #
+    #   Album.new(name: 'Foo', copies_sold: 1000).
+    #     insert_conflict(
+    #       target: :name,
+    #       update: {copies_sold: Sequel[:excluded][:b]}
+    #     ).
+    #     save
+    #
+    # This example will try to insert the album, but if there is an existing
+    # album with the name 'Foo', this will update the copies_sold attribute
+    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # the options you can pass to the insert_conflict method.
+    #
+    # You should not attempt to use this plugin to ignore conflicts when
+    # inserting, you should only use it to turn insert conflicts into updates.
+    # Any usage to ignore conflicts is not recommended or supported.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support insert_conflict
+    #   Sequel::Model.plugin :insert_conflict
+    #
+    #   # Make the Album class support insert_conflict
+    #   Album.plugin :insert_conflict
+    module InsertConflict
+      def self.configure(model)
+        model.instance_exec do
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
+            raise Error, "#{self}'s dataset does not support insert_conflict"
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the insert_conflict options to pass to the dataset when inserting. 
+        def insert_conflict(opts=OPTS)
+          raise Error, "Model#insert_conflict is only supported on new model instances" unless new?
+          @insert_conflict_opts = opts
+          self
+        end
+
+        private
+
+        # Set the dataset used for inserting to use INSERT ON CONFLICT
+        # Model#insert_conflict has been called on the instance previously.
+        def _insert_dataset
+          ds = super
+
+          if @insert_conflict_opts
+            ds = ds.insert_conflict(@insert_conflict_opts)
+          end
+
+          ds
+        end
+
+        # Disable the use of prepared insert statements, as they are not compatible
+        # with this plugin.
+        def use_prepared_statements_for?(type)
+          return false if type == :insert || type == :insert_select
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # If the model's dataset selects explicit columns (or table.*) and the
+    # database supports it, the insert_returning_select plugin will
+    # automatically set the RETURNING clause on the dataset used to
+    # insert rows to the columns selected, which allows the default model
+    # support to run the insert and refresh of the data in a single
+    # query, instead of two separate queries.  This is Sequel's default
+    # behavior when the model does not select explicit columns.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses automatically setup insert returning clauses
+    #   Sequel::Model.plugin :insert_returning_select
+    #
+    #   # Make the Album class automatically setup insert returning clauses
+    #   Album.plugin :insert_returning_select
+    module InsertReturningSelect
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model)
+        model.instance_exec do
+          self.dataset = dataset if @dataset && @dataset.opts[:select]
+        end
+      end
+
+      module ClassMethods
+        # The dataset to use to insert new rows.  For internal use only.
+        attr_reader :instance_insert_dataset
+
+        private
+
+        # When reseting the instance dataset, also reset the instance_insert_dataset.
+        def reset_instance_dataset
+          ret = super
+          return unless ds = @instance_dataset
+
+          if columns = insert_returning_columns(ds)
+            ds = ds.returning(*columns)
+          end
+          @instance_insert_dataset = ds
+
+          ret
+        end
+
+        RETURN_ALL = [Sequel::Dataset::WILDCARD].freeze
+        private_constant :RETURN_ALL
+
+        # Determine the columns to use for the returning clause, or return nil
+        # if they can't be determined and a returning clause should not be
+        # added automatically.
+        def insert_returning_columns(ds)
+          return unless ds.supports_returning?(:insert)
+          return unless values = ds.opts[:select]
+
+          # SELECT table.* -> RETURNING *
+          if values.length == 1 && values[0].is_a?(Sequel::SQL::ColumnAll)
+            return RETURN_ALL
+          end
+
+          # SELECT column1, table.column2, ... -> RETURNING column1, column2, ...
+          values = values.map{|v| ds.unqualified_column_for(v)}
+          if values.all?
+            values
+          end
+        end
+      end
+      
+      module InstanceMethods
+        private
+
+        # Use the instance_insert_dataset as the base dataset for the insert.
+        def _insert_dataset
+          use_server(model.instance_insert_dataset)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The inspect_pk plugin includes the pk right next to the
+    # model name in inspect, allowing for easily copying and
+    # pasting to retrieve a copy of the object:
+    #
+    #   Album.with_pk(1).inspect
+    #   #         default: #<Album @values={...}>
+    #   # with inspect_pk: #<Album[1] @values={...}>
+    #
+    # Usage:
+    #
+    #   # Make all model instances include pk in inspect output
+    #   Sequel::Model.plugin :inspect_pk
+    #
+    #   # Make Album instances include pk in inspect output
+    #   Album.plugin :inspect_pk
+    module InspectPk
+      module InstanceMethods
+        private
+
+        # The primary key value to include in the inspect output, if any.
+        # For composite primary keys, this only includes a value if all
+        # fields are present.
+        def inspect_pk
+          if primary_key && (pk = self.pk) && (!(Array === pk) || pk.all?)
+            pk
+          end
+        end
+
+        # Include the instance's primary key in the output.
+        def inspect_prefix
+          if v = inspect_pk
+            "#{super}[#{v.inspect}]"
+          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/instance_filters.rb

@@ -0,0 +1,138 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # This plugin allows you to add filters on a per object basis that
+    # restrict updating or deleting the object.  It's designed for cases
+    # where you would normally have to drop down to the dataset level
+    # to get the necessary control, because you only want to delete or
+    # update the rows in certain cases based on the current status of
+    # the row in the database.  The main purpose of this plugin is to
+    # avoid race conditions by relying on the atomic properties of database
+    # transactions.
+    # 
+    #   class Item < Sequel::Model
+    #     plugin :instance_filters
+    #   end
+    #
+    #   # These are two separate objects that represent the same
+    #   # database row. 
+    #   i1 = Item.first(id: 1, delete_allowed: false)
+    #   i2 = Item.first(id: 1, delete_allowed: false)
+    #
+    #   # Add an instance filter to the object. This filter is in effect
+    #   # until the object is successfully updated or deleted.
+    #   i1.instance_filter(delete_allowed: true)
+    #
+    #   # Attempting to delete the object where the filter doesn't
+    #   # match any rows raises an error.
+    #   i1.delete # raises Sequel::NoExistingObject
+    #
+    #   # The other object that represents the same row has no
+    #   # instance filters, and can be updated normally.
+    #   i2.update(delete_allowed: true)
+    #
+    #   # Even though the filter is now still in effect, since the
+    #   # database row has been updated to allow deleting,
+    #   # delete now works.
+    #   i1.delete
+    #
+    # This plugin sets the require_modification flag on the model,
+    # so if the model's dataset doesn't provide an accurate number
+    # of matched rows, this could result in invalid exceptions being raised.
+    module InstanceFilters
+      # Exception class raised when updating or deleting an object does
+      # not affect exactly one row.
+      Error = Sequel::NoExistingObject
+      
+      # Set the require_modification flag to true for the model.
+      def self.configure(model)
+        model.require_modification = true
+      end
+
+      module InstanceMethods
+        # Clear the instance filters after successfully destroying the object.
+        def after_destroy
+          super
+          clear_instance_filters
+        end
+        
+        # Clear the instance filters after successfully updating the object.
+        def after_update
+          super
+          clear_instance_filters
+        end
+
+        # Freeze the instance filters when freezing the object
+        def freeze
+          instance_filters.freeze
+          super
+        end
+      
+        # Add an instance filter to the array of instance filters
+        # Both the arguments given and the block are passed to the
+        # dataset's filter method.
+        def instance_filter(*args, &block)
+          instance_filters << [args, block]
+        end
+      
+        private
+        
+        # If there are any instance filters, make sure not to use the
+        # instance delete optimization.
+        def _delete_without_checking
+          if @instance_filters && !@instance_filters.empty?
+            _delete_dataset.delete 
+          else
+            super
+          end
+        end
+
+        # Duplicate internal structures when duplicating model instance.
+        def initialize_copy(other)
+          super
+          @instance_filters = other.send(:instance_filters).dup
+          self
+        end
+      
+        # Lazily initialize the instance filter array.
+        def instance_filters
+          @instance_filters ||= []
+        end
+        
+        # Apply the instance filters to the given dataset
+        def apply_instance_filters(ds)
+          instance_filters.inject(ds) do |ds1, i|
+            block = i[1]
+            ds1.where(*i[0], &block)
+          end
+        end
+        
+        # Clear the instance filters.
+        def clear_instance_filters
+          instance_filters.clear
+        end
+        
+        # Apply the instance filters to the dataset returned by super.
+        def _delete_dataset
+          apply_instance_filters(super)
+        end
+        
+        # Apply the instance filters to the dataset returned by super.
+        def _update_dataset
+          apply_instance_filters(super)
+        end
+
+        # Only use prepared statements for update and delete queries
+        # if there are no instance filters.
+        def use_prepared_statements_for?(type)
+          if type == :update && !instance_filters.empty?
+            false
+          else
+            super if defined?(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/instance_hooks.rb

@@ -0,0 +1,115 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The instance_hooks plugin allows you to add hooks to specific instances,
+    # by passing a block to a _hook method (e.g. before_save_hook{do_something}).
+    # The block is executed when the hook is called (e.g. before_save).
+    #
+    # All of the standard hooks are supported.
+    # Instance level before hooks are executed in reverse order of addition before
+    # calling super.  Instance level after hooks are executed in order of addition
+    # after calling super.
+    #
+    # Instance level hooks for before and after are cleared after all related
+    # after level instance hooks have run.  This means that if you add a before_create
+    # and before_update instance hooks to a new object, the before_create hook will
+    # be run the first time you save the object (creating it), and the before_update
+    # hook will be run the second time you save the object (updating it), and no
+    # hooks will be run the third time you save the object.
+    #
+    # Validation hooks are not cleared until after a successful save.
+    # 
+    # Usage:
+    #
+    #   # Add the instance hook methods to all model subclass instances (called before loading subclasses)
+    #   Sequel::Model.plugin :instance_hooks
+    #
+    #   # Add the instance hook methods just to Album instances
+    #   Album.plugin :instance_hooks
+    module InstanceHooks
+      module InstanceMethods 
+        Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
+          def #{h}_hook(&block)
+            raise Sequel::Error, "can't add hooks to frozen object" if frozen?
+            add_instance_hook(:#{h}, &block)
+            self
+          end
+        END
+        
+        [:before_create, :before_update, :before_validation].each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) if @instance_hooks; super end", __FILE__, __LINE__)}
+        [:after_create, :after_update].each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}
+          def #{h}
+            super
+            return unless @instance_hooks
+            run_after_instance_hooks(:#{h})
+            @instance_hooks.delete(:#{h})
+            @instance_hooks.delete(:#{h.to_s.sub('after', 'before')})
+          end
+        END
+
+        # Run after destroy instance hooks.
+        def after_destroy
+          super
+          return unless @instance_hooks
+          run_after_instance_hooks(:after_destroy)
+          @instance_hooks.delete(:after_destroy)
+          @instance_hooks.delete(:before_destroy)
+        end
+
+        # Run after validation instance hooks.
+        def after_validation
+          super
+          return unless @instance_hooks
+          run_after_instance_hooks(:after_validation)
+        end
+        
+        # Run after save instance hooks.
+        def after_save
+          super
+          return unless @instance_hooks
+          run_after_instance_hooks(:after_save)
+          @instance_hooks.delete(:after_save)
+          @instance_hooks.delete(:before_save)
+          @instance_hooks.delete(:after_validation)
+          @instance_hooks.delete(:before_validation)
+        end
+
+        # Run before_destroy instance hooks.
+        def before_destroy
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_destroy)
+          super
+        end
+
+        # Run before_save instance hooks.
+        def before_save
+          return super unless @instance_hooks
+          run_before_instance_hooks(:before_save)
+          super
+        end
+        
+        private
+        
+        # Add the block as an instance level hook.  For before hooks, add it to
+        # the beginning of the instance hook's array.  For after hooks, add it
+        # to the end.
+        def add_instance_hook(hook, &block)
+          instance_hooks(hook).public_send(hook.to_s.start_with?('before') ? :unshift : :push, block)
+        end
+        
+        # An array of instance level hook blocks for the given hook type.
+        def instance_hooks(hook)
+          @instance_hooks ||= {}
+          @instance_hooks[hook] ||= []
+        end
+        
+        # Run all hook blocks of the given hook type.
+        def run_after_instance_hooks(hook)
+          instance_hooks(hook).each(&:call)
+        end
+        alias run_before_instance_hooks run_after_instance_hooks
+      end
+    end
+  end
+end