serrano-vk 0.1.0

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

@@ -0,0 +1,276 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The dirty plugin makes Sequel save the initial value of
+    # a column when setting a new value for the column.  This
+    # makes it easier to see what changes were made to the object:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.initial_value(:name)   # 'Foo'
+    #   artist.column_change(:name)   # ['Foo', 'Bar']
+    #   artist.column_changes         # {:name => ['Foo', 'Bar']}
+    #   artist.column_changed?(:name) # true
+    #   artist.reset_column(:name)
+    #   artist.name                   # => 'Foo'
+    #   artist.column_changed?(:name) # false
+    #
+    # It also makes changed_columns more accurate in that it
+    # can detect when a the column value is changed and then
+    # changed back:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.changed_columns        # => [:name]
+    #   artist.name = 'Foo'
+    #   artist.changed_columns        # => []
+    #
+    # It can handle situations where a column value is
+    # modified in place:
+    #
+    #   artist.will_change_column(:name)
+    #   artist.name.gsub!(/o/, 'u')
+    #   artist.changed_columns       # => [:name]
+    #   artist.initial_value(:name)  # => 'Foo'
+    #   artist.column_change(:name)  # => ['Foo', 'Fuu']
+    #
+    # It also saves the previously changed values after an update:
+    #
+    #   artist.update(name: 'Bar')
+    #   artist.column_changes        # => {}
+    #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
+    #
+    #   artist.column_previously_was(:name)
+    #   # => 'Foo'
+    #   artist.column_previously_changed?(:name)
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Bar')
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Baz')
+    #   # => false
+    #
+    # There is one caveat; when used with a column that also uses the
+    # serialization plugin, setting the column back to its original value
+    # after changing it is not correctly detected and will leave an entry
+    # in changed_columns.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass instances record previous values (called before loading subclasses)
+    #   Sequel::Model.plugin :dirty
+    #
+    #   # Make the Album class record previous values
+    #   Album.plugin :dirty
+    module Dirty
+      module InstanceMethods
+        # A hash of previous changes before the object was
+        # saved, in the same format as #column_changes.
+        # Note that this is not necessarily the same as the columns
+        # that were used in the update statement.
+        attr_reader :previous_changes
+
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
+        # An array with the initial value and the current value
+        # of the column, if the column has been changed.  If the
+        # column has not been changed, returns nil.
+        #
+        #   column_change(:name) # => ['Initial', 'Current']
+        def column_change(column)
+          [initial_value(column), get_column_value(column)] if column_changed?(column)
+        end
+
+        # A hash with column symbol keys and pairs of initial and
+        # current values for all changed columns.
+        #
+        #   column_changes # => {:name => ['Initial', 'Current']}
+        def column_changes
+          h = {}
+          initial_values.each do |column, value|
+            h[column] = [value, get_column_value(column)]
+          end
+          h
+        end
+
+        # Either true or false depending on whether the column has
+        # changed.  Note that this is not exactly the same as checking if
+        # the column is in changed_columns, if the column was not set
+        # initially.
+        #
+        #   column_changed?(:name) # => true
+        def column_changed?(column)
+          initial_values.has_key?(column)
+        end
+
+        # Whether the column was previously changed.
+        # Options:
+        # :from :: If given, the previous initial value of the column must match this
+        # :to :: If given, the previous changed value of the column must match this
+        #
+        #   update(name: 'Current')
+        #   previous_changes                  # => {:name=>['Initial', 'Current']}
+        #   column_previously_changed?(:name) # => true
+        #   column_previously_changed?(:id)   # => false
+        #   column_previously_changed?(:name, from: 'Initial', to: 'Current') # => true
+        #   column_previously_changed?(:name, from: 'Foo', to: 'Current')     # => false
+        def column_previously_changed?(column, opts=OPTS)
+          return false unless (pc = @previous_changes) && (val = pc[column])
+
+          if opts.has_key?(:from)
+            return false unless val[0] == opts[:from]
+          end
+
+          if opts.has_key?(:to)
+            return false unless val[1] == opts[:to]
+          end
+
+          true
+        end
+
+        # The previous value of the column, which is the initial value of
+        # the column before the object was previously saved.
+        #
+        #   initial_value(:name) # => 'Initial'
+        #   update(name: 'Current')
+        #   column_previously_was(:name) # => 'Initial'
+        def column_previously_was(column)
+          (pc = @previous_changes) && (val = pc[column]) && val[0]
+        end
+
+        # Freeze internal data structures
+        def freeze
+          initial_values.freeze
+          missing_initial_values.freeze
+          @previous_changes.freeze if @previous_changes
+          super
+        end
+
+        # The initial value of the given column.  If the column value has
+        # not changed, this will be the same as the current value of the
+        # column.
+        #
+        #   initial_value(:name) # => 'Initial'
+        def initial_value(column)
+          initial_values.fetch(column){get_column_value(column)}
+        end
+
+        # A hash with column symbol keys and initial values.
+        #
+        #   initial_values # {:name => 'Initial'}
+        def initial_values
+          @initial_values ||= {}
+        end
+
+        # Reset the column to its initial value.  If the column was not set
+        # initial, removes it from the values.
+        #
+        #   reset_column(:name)
+        #   name # => 'Initial'
+        def reset_column(column)
+          if initial_values.has_key?(column)
+            set_column_value(:"#{column}=", initial_values[column])
+          end
+          if missing_initial_values.include?(column)
+            values.delete(column)
+          end
+        end
+
+        # Manually specify that a column will change.  This should only be used
+        # if you plan to modify a column value in place, which is not recommended.
+        #
+        #   will_change_column(:name)
+        #   name.gsub(/i/i, 'o')
+        #   column_change(:name) # => ['Initial', 'onotoal']
+        def will_change_column(column)
+          _add_changed_column(column)
+          check_missing_initial_value(column)
+
+          value = if initial_values.has_key?(column)
+            initial_values[column]
+          else
+            get_column_value(column)
+          end
+
+          initial_values[column] = if value && value != true && value.respond_to?(:clone)
+            begin
+              value.clone
+            rescue TypeError
+              value
+            end
+          else
+            value
+          end
+        end
+
+        private
+
+        # Reset initial values when clearing changed columns
+        def _clear_changed_columns(reason)
+          reset_initial_values if reason == :initialize || reason == :refresh
+          super
+        end
+
+        # When changing the column value, save the initial column value.  If the column
+        # value is changed back to the initial value, update changed columns to remove
+        # the column.
+        def change_column_value(column, value)
+          if (iv = initial_values).has_key?(column)
+            initial = iv[column]
+            super
+            if value == initial
+              _changed_columns.delete(column) unless missing_initial_values.include?(column)
+              iv.delete(column)
+            end
+          else
+            check_missing_initial_value(column)
+            iv[column] = get_column_value(column)
+            super
+          end
+        end
+
+        # If the values hash does not contain the column, make sure missing_initial_values
+        # does so that it doesn't get deleted from changed_columns if changed back,
+        # and so that resetting the column value can be handled correctly.
+        def check_missing_initial_value(column)
+          unless values.has_key?(column) || (miv = missing_initial_values).include?(column)
+            miv << column
+          end
+        end
+
+        # Duplicate internal data structures
+        def initialize_copy(other)
+          super
+          @initial_values = Hash[other.initial_values]
+          @missing_initial_values = other.send(:missing_initial_values).dup
+          @previous_changes = Hash[other.previous_changes] if other.previous_changes
+          self
+        end
+
+        # Array holding column symbols that were not present initially.  This is necessary
+        # to differentiate between values that were not present and values that were
+        # present but equal to nil.
+        def missing_initial_values
+          @missing_initial_values ||= []
+        end
+
+        # Clear the data structures that store the initial values.
+        def reset_initial_values
+          @initial_values.clear if @initial_values
+          @missing_initial_values.clear if @missing_initial_values
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The eager_each plugin makes calling each on an eager loaded dataset do eager loading.
+    # By default, each does not work on an eager loaded dataset, because each iterates
+    # over rows of the dataset as they come in, and to eagerly load you need to have all
+    # values up front.  With the default associations code, you must call #all on an eagerly
+    # loaded dataset, as calling #each on an #eager dataset skips the eager loading, and calling
+    # #each on an #eager_graph dataset makes it yield plain hashes with columns from all
+    # tables, instead of yielding the instances of the main model.
+    #
+    # This plugin makes #each call #all for eagerly loaded datasets.  As #all usually calls
+    # #each, this is a bit of issue, but this plugin resolves the issue by cloning the dataset
+    # and setting a new flag in the cloned dataset, so that each can check with the flag to
+    # determine whether it should call all.
+    #
+    # This plugin also makes #first and related methods that load single records work with
+    # eager loading.  Note that when using eager_graph, calling #first or a similar method
+    # will result in two queries, one to load the main object, and one to eagerly load all associated
+    # objects to that main object.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_each
+    #
+    #   # Make the Album class eagerly load for each
+    #   Album.plugin :eager_each
+    module EagerEach 
+      module DatasetMethods
+        # Don't call #all when attempting to load the columns.
+        def columns!
+          if use_eager_all?
+            clone(:all_called=>true).columns!
+          else
+            super
+          end
+        end
+
+        # Call #all instead of #each if eager loading,
+        # unless #each is being called by #all.
+        def each(&block)
+          if use_eager_all?
+            all(&block)
+          else
+            super
+          end
+        end
+
+        # If eager loading, clone the dataset and set a flag to let #each know not to call #all,
+        # to avoid the infinite loop.
+        def all(&block)
+          if use_eager_all?
+            clone(:all_called=>true).all(&block)
+          else
+            super
+          end
+        end
+
+        # Handle eager loading when calling first and related methods.  For eager_graph,
+        # this does an additional query after retrieving a single record, because otherwise
+        # the associated records won't get eager loaded correctly.
+        def single_record!
+          if use_eager_all?
+            obj = clone(:all_called=>true).all.first
+
+            if opts[:eager_graph]
+              obj = clone(:all_called=>true).where(obj.qualified_pk_hash).unlimited.all.first
+            end
+
+            obj
+          else
+            super
+          end
+        end
+
+        private
+
+        # Wether to use all when each is called, true when eager loading
+        # unless the flag has already been set.
+        def use_eager_all?
+          (opts[:eager] || opts[:eager_graph]) && !opts[:all_called]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The eager_graph_eager plugin allows for chaining eager loads after eager_graph
+    # loads.  Given the following model associations:
+    #
+    #   Band.one_to_many :albums
+    #   Album.one_to_many :tracks
+    #
+    # Let's say you wanted to return bands ordered by album name, and eagerly load
+    # those albums, you can do that using:
+    #
+    #   Band.eager_graph(:albums).order{albums[:name]}
+    #
+    # Let's say you also wanted to eagerly load the tracks for each album. You could
+    # just add them to the eager_graph call:
+    #  
+    #   Band.eager_graph(albums: :tracks).order{albums[:name]}
+    #
+    # However, the bloats the result set, and you aren't ordering by the track
+    # information, so a join is not required.  The eager_graph_eager plugin allows
+    # you to specify that the tracks be eagerly loaded in a separate query after
+    # the eager_graph load of albums:
+    # 
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], :tracks).order{albums[:name]}
+    #
+    # <tt>Dataset#eager_graph_eager</tt>'s first argument is a dependency chain, specified
+    # as an array of symbols.  This specifies the point at which to perform the eager load.
+    # The remaining arguments are arguments that could be passed to Dataset#eager to specify
+    # what dependent associations should be loaded at that point.
+    #
+    # If you also have the following model association:
+    #
+    #   Track.one_to_many :lyrics
+    #
+    # Here's some different ways of performing eager loading:
+    #
+    #   # 4 Queries: bands, albums, tracks, lyrics
+    #   Band.eager(albums: {tracks: :lyrics})
+    #
+    #   # 1 Query: bands+albums+tracks+lyrics
+    #   Band.eager_graph(albums: {tracks: :lyrics})
+    #
+    #   # 3 Queries: bands+albums, tracks, lyrics
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], tracks: :lyrics)
+    #
+    #   # 2 Queries: bands+albums+tracks, lyrics
+    #   Band.eager_graph(albums: :tracks).eager_graph_eager([:albums, :tracks], :lyrics)
+    #
+    #   # 2 Queries: bands+albums, tracks+lyrics
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], tracks: proc{|ds| ds.eager_graph(:lyrics)})
+    #
+    # Usage:
+    #
+    #   # Support eager_graph_eager in all subclass datasets (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_graph_eager
+    #
+    #   # Support eager_graph_eager in Album class datasets
+    #   Album.plugin :eager_graph_eager
+    module EagerGraphEager
+      module DatasetMethods
+        # Specify for the given dependency chain, after loading objects for the
+        # current dataset via eager_graph, eagerly load the given associations at that point in the
+        # dependency chain.
+        #
+        # dependency_chain :: Array of association symbols, with the first association symbol
+        #                     specifying an association in the dataset's model, the next
+        #                     association specifying an association in the previous association's
+        #                     associated model, and so on.
+        # assocs :: Symbols or hashes specifying associations to eagerly load at the point
+        #           specified by the dependency chain.
+        def eager_graph_eager(dependency_chain, *assocs)
+          unless dependency_chain.is_a?(Array) && dependency_chain.all?{|s| s.is_a?(Symbol)} && !dependency_chain.empty?
+            raise Error, "eager_graph_eager first argument must be array of symbols"
+          end
+
+          current = model
+          deps = dependency_chain.map do |dep|
+            unless ref = current.association_reflection(dep)
+              raise Error, "invalid association #{dep.inspect} for #{current.inspect}"
+            end
+            current = ref.associated_class
+            [dep, ref.returns_array?]
+          end
+          assocs = current.dataset.send(:eager_options_for_associations, assocs)
+
+          deps.each(&:freeze)
+          deps.unshift(current)
+          deps.freeze
+
+          assocs.freeze
+
+          if h = @opts[:eager_graph_eager]
+            h = Hash[h]
+            h[deps] = assocs
+          else
+            h = {deps => assocs}
+          end
+
+          clone(:eager_graph_eager=>h.freeze)
+        end
+
+        protected
+
+        # After building objects from the rows, if eager_graph_eager has been
+        # called on the datasets, for each dependency chain specified, eagerly
+        # load the appropriate associations.
+        def eager_graph_build_associations(rows)
+          objects = super
+
+          if eager_data = @opts[:eager_graph_eager]
+            eager_data.each do |deps, assocs|
+              current = objects
+
+              last_class, *deps = deps
+              deps.each do |dep, is_multiple|
+                current_assocs = current.map(&:associations)
+
+                if is_multiple
+                  current = current_assocs.flat_map{|a| a[dep]}
+                else
+                  current = current_assocs.map{|a| a[dep]}
+                  current.compact!
+                end
+
+                current.uniq!(&:object_id)
+              end
+
+              last_class.dataset.send(:eager_load, current, assocs)
+            end
+          end
+
+          objects
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The empty_failure_backtraces plugin uses empty backtraces when raising HookFailed and ValidationFailed
+    # exceptions.  This can be significantly faster, and if you are using these exceptions for
+    # flow control, you do not need the backtraces.  This plugin is about 10% faster on CRuby
+    # and 10-15x faster on JRuby 9.2.7.0+.  This does not have an effect on JRuby <9.2.7.0.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass instances use empty backtraces for HookFailed
+    #   # and ValidationFailed exceptions (called before loading subclasses)
+    #   Sequel::Model.plugin :empty_failure_backtraces
+    #
+    #   # Make the Album class use empty backtraces for HookFailed and ValidationFailed exceptions
+    #   Album.plugin :empty_failure_backtraces
+    module EmptyFailureBacktraces
+      module InstanceMethods
+        private
+
+        # Use empty backtrace for HookFailed exceptions.
+        def hook_failed_error(msg)
+          e = super
+          e.set_backtrace([])
+          e
+        end
+
+        # Use empty backtrace for ValidationFailed exceptions.
+        def validation_failed_error
+          e = super
+          e.set_backtrace([])
+          e
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The enum plugin allows for easily adding methods to modify the value of
+    # a column.  It allows treating the column itself as an enum, returning a
+    # symbol for the related enum value.  It also allows for setting up dataset
+    # methods to easily find records having or not having each enum value.
+    #
+    # After loading the plugin, you can call the +enum+ method to define the
+    # methods.  The +enum+ method accepts a symbol for the underlying
+    # database column, and a hash with symbol keys for the enum values.
+    # For example, the following call:
+    #
+    #   Album.enum :status_id, good: 1, bad: 2
+    #
+    # Will define the following instance methods:
+    #
+    # Album#good! :: Change +status_id+ to +1+ (does not save the receiver)
+    # Album#bad! :: Change +status_id+ to +2+ (does not save the receiver)
+    # Album#good? :: Return whether +status_id+ is +1+
+    # Album#bad? :: Return whether +status_id+ is +2+
+    #
+    # It will override the following instance methods:
+    #
+    # Album#status_id :: Return +:good+/+:bad+ instead of +1+/+2+ (other values returned as-is)
+    # Album#status_id= :: Allow calling with +:good+/+:bad+ to set +status_id+ to +1+/+2+ (other values,
+    #                     such as <tt>'good'</tt>/<tt>'bad'</tt> set as-is)
+    #
+    # If will define the following dataset methods:
+    #
+    # Album.dataset.good :: Return a dataset filtered to rows where +status_id+ is +1+
+    # Album.dataset.not_good :: Return a dataset filtered to rows where +status_id+ is not +1+
+    # Album.dataset.bad:: Return a dataset filtered to rows where +status_id+ is +2+
+    # Album.dataset.not_bad:: Return a dataset filtered to rows where +status_id+ is not +2+
+    #
+    # When calling +enum+, you can also provide the following options:
+    #
+    # :prefix :: Use a prefix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the prefix.
+    #            For example, with <tt>prefix: 'status'</tt>, the instance methods defined above would be +status_good?+, +status_bad?+,
+    #            +status_good!+, and +status_bad!+, and the dataset methods defined would be +status_good+, +status_not_good+, +status_bad+,
+    #            and +status_not_bad+.
+    # :suffix :: Use a suffix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the suffix.
+    #            For example, with <tt>suffix: 'status'</tt>, the instance methods defined above would be +good_status?+, +bad_status?+,
+    #            +good_status!+, and +bad_status!+, and the dataset methods defined would be +good_status+, +not_good_status+, +bad_status+,
+    #            and +not_bad_status+.
+    # :override_accessors :: Set to +false+ to not override the column accessor methods.
+    # :dataset_methods :: Set to +false+ to not define dataset methods.
+    #
+    # Note that this does not use a true enum column in the database.  If you are
+    # looking for enum support in the database, and your are using PostgreSQL,
+    # Sequel supports that via the pg_enum Database extension.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses handle enums
+    #   Sequel::Model.plugin :enum
+    #
+    #   # Make the Album class handle enums
+    #   Album.plugin :enum
+    module Enum
+      module ClassMethods
+        # Define instance and dataset methods in this class to treat column
+        # as a enum.  See Enum documentation for usage.
+        def enum(column, values, opts=OPTS)
+          raise Sequel::Error, "enum column must be a symbol" unless column.is_a?(Symbol)
+          raise Sequel::Error, "enum values must be provided as a hash with symbol keys" unless values.is_a?(Hash) && values.all?{|k,| k.is_a?(Symbol)}
+
+          if prefix = opts[:prefix]
+            prefix = column if prefix == true
+            prefix = "#{prefix}_"
+          end
+
+          if suffix = opts[:suffix]
+            suffix = column if suffix == true
+            suffix = "_#{suffix}"
+          end
+          
+          values = Hash[values].freeze
+          inverted = values.invert.freeze
+
+          unless @enum_methods
+            @enum_methods = Sequel.set_temp_name(Module.new){"#{name}::@enum_methods"}
+            include @enum_methods
+          end
+
+          @enum_methods.module_eval do
+            unless opts[:override_accessors] == false
+              define_method(column) do
+                v = super()
+                inverted.fetch(v, v)
+              end
+
+              define_method(:"#{column}=") do |v|
+                super(values.fetch(v, v))
+              end
+            end
+
+            values.each do |key, value|
+              define_method(:"#{prefix}#{key}#{suffix}!") do
+                self[column] = value
+                nil
+              end
+
+              define_method(:"#{prefix}#{key}#{suffix}?") do
+                self[column] == value
+              end
+            end
+          end
+
+          unless opts[:dataset_methods] == false
+            dataset_module do
+              values.each do |key, value|
+                cond = Sequel[column=>value]
+                where :"#{prefix}#{key}#{suffix}", cond
+                where :"#{prefix}not_#{key}#{suffix}", ~cond
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end