tdiary 5.2.3 → 5.3.0

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.59.0/lib/sequel/plugins/empty_failure_backtraces.rb

@@ -1,38 +0,0 @@
-# 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/vendor/bundle/ruby/3.1.0/gems/sequel-5.59.0/lib/sequel/plugins/enum.rb

@@ -1,124 +0,0 @@
-# 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 = Module.new
-            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

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.59.0/lib/sequel/plugins/error_splitter.rb

@@ -1,61 +0,0 @@
-# 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/vendor/bundle/ruby/3.1.0/gems/sequel-5.59.0/lib/sequel/plugins/finder.rb

@@ -1,246 +0,0 @@
-# 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.
-        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
-
-              Sequel::Dataset::PlaceholderLiteralizer.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/vendor/bundle/ruby/3.1.0/gems/sequel-5.59.0/lib/sequel/plugins/forbid_lazy_load.rb

@@ -1,216 +0,0 @@
-# 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
-    #
-    # 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
-    module ForbidLazyLoad
-      # 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 DatasetMethods
-        # 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