tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.56.0/lib/sequel/plugins/insert_conflict.rb

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

@@ -1,203 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Plugins
-    # The list plugin allows for model instances to be part of an ordered list,
-    # based on a position field in the database.  It can either consider all
-    # rows in the table as being from the same list, or you can specify scopes
-    # so that multiple lists can be kept in the same table.
-    # 
-    # Basic Example:
-    #
-    #   class Item < Sequel::Model(:items)
-    #     plugin :list # will use :position field for position
-    #     plugin :list, field: :pos # will use :pos field for position
-    #   end
-    #   
-    #   item = Item[1]
-    # 
-    #   # Get the next or previous item in the list
-    # 
-    #   item.next
-    #   item.prev
-    # 
-    #   # Modify the item's position, which may require modifying other items in
-    #   # the same list
-    # 
-    #   item.move_to(3)
-    #   item.move_to_top
-    #   item.move_to_bottom
-    #   item.move_up
-    #   item.move_down
-    # 
-    # You can provide a <tt>:scope</tt> option to scope the list.  This option
-    # can be a symbol or array of symbols specifying column name(s), or a proc
-    # that accepts a model instance and returns a dataset representing the list
-    # the object is in.
-    # 
-    # For example, if each item has a +user_id+ field, and you want every user
-    # to have their own list:
-    #
-    #   Item.plugin :list, scope: :user_id
-    # 
-    # Note that using this plugin modifies the order of the model's dataset to
-    # sort by the position and scope fields.  Also note that this plugin is subject to
-    # race conditions, and is not safe when concurrent modifications are made
-    # to the same list.
-    #
-    # Note that by default, unlike ruby arrays, the list plugin assumes the first
-    # entry in the list has position 1, not position 0.
-    #
-    # You can change this by providing an integer <tt>:top</tt> option:
-    #
-    #   Item.plugin :list, top: 0
-    #
-    # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
-    module List
-      # Set the +position_field+, +scope_proc+ and +top_of_list+ attributes for the model,
-      # using the <tt>:field</tt>, <tt>:scope</tt>, and <tt>:top</tt> options, respectively.
-      # The <tt>:scope</tt> option can be a symbol, array of symbols, or a proc that
-      # accepts a model instance and returns a dataset representing the list.
-      # Also, modify the model dataset's order to order by the position and scope fields.
-      def self.configure(model, opts = OPTS)
-        model.position_field = opts[:field] || :position
-        model.dataset = model.dataset.order_prepend(model.position_field)
-        model.instance_exec do
-          @top_of_list = opts[:top] || 1
-        end
-        
-        model.scope_proc = case scope = opts[:scope]
-        when Symbol
-          model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.where(scope=>obj.public_send(scope))}
-        when Array
-          model.dataset = model.dataset.order_prepend(*scope)
-          proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
-        else
-          scope
-        end
-      end
-
-      module ClassMethods
-        # The column name holding the position in the list, as a symbol.
-        attr_accessor :position_field
-
-        # A proc that scopes the dataset, so that there can be multiple positions 
-        # in the list, but the positions are unique with the scoped dataset. This
-        # proc should accept an instance and return a dataset representing the list.
-        attr_accessor :scope_proc
-
-        # An Integer to use as the position of the top of the list. Defaults to 1.
-        attr_reader :top_of_list
-
-        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil, :@top_of_list=>nil)
-      end
-
-      module InstanceMethods
-        # The model object at the given position in the list containing this instance.
-        def at_position(p)
-          list_dataset.first(position_field => p)
-        end
-
-        # When destroying an instance, move all entries after the instance down
-        # one position, so that there aren't any gaps
-        def after_destroy
-          super
-
-          f = Sequel[position_field]
-          list_dataset.where(f > position_value).update(f => f - 1)
-        end
-
-        # Find the last position in the list containing this instance.
-        def last_position
-          list_dataset.max(position_field).to_i
-        end
-
-        # A dataset that represents the list containing this instance.
-        def list_dataset
-          model.scope_proc ? model.scope_proc.call(self) : model.dataset
-        end
-
-        # Move this instance down the given number of places in the list,
-        # or 1 place if no argument is specified.
-        def move_down(n = 1)
-          move_to(position_value + n)
-        end
-
-        # Move this instance to the given place in the list.  If lp is not
-        # given or greater than the last list position, uses the last list
-        # position.  If lp is less than the top list position, uses the
-        # top list position.
-        def move_to(target, lp = nil)
-          current = position_value
-          if target != current
-            checked_transaction do
-              ds = list_dataset
-              op, ds = if target < current
-                target = model.top_of_list if target < model.top_of_list
-                [:+, ds.where(position_field=>target...current)]
-              else
-                lp ||= last_position
-                target = lp if target > lp
-                [:-, ds.where(position_field=>(current + 1)..target)]
-              end
-              ds.update(position_field => Sequel::SQL::NumericExpression.new(op, position_field, 1))
-              update(position_field => target)
-            end
-          end
-          self
-        end
-
-        # Move this instance to the bottom (last position) of the list.
-        def move_to_bottom
-          lp = last_position 
-          move_to(lp, lp)
-        end
-
-        # Move this instance to the top (first position, usually position 1) of the list.
-        def move_to_top
-          move_to(model.top_of_list)
-        end
-
-        # Move this instance the given number of places up in the list, or 1 place
-        # if no argument is specified.
-        def move_up(n = 1)
-          move_to(position_value - n) 
-        end
-
-        # The model instance the given number of places below this model instance
-        # in the list, or 1 place below if no argument is given.
-        def next(n = 1)
-          n == 0 ? self : at_position(position_value + n)
-        end
-
-        # The value of the model's position field for this instance.
-        def position_value
-          get_column_value(position_field)
-        end
-
-        # The model instance the given number of places below this model instance
-        # in the list, or 1 place below if no argument is given.
-        def prev(n = 1)
-          self.next(n * -1)
-        end
-
-        # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
-        def before_validation
-          unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
-          end
-          super
-        end
-
-        private
-
-        # The model's position field, an instance method for ease of use.
-        def position_field
-          model.position_field
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.56.0/lib/sequel/plugins/tactical_eager_loading.rb

@@ -1,205 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Plugins
-    # The tactical_eager_loading plugin allows you to eagerly load
-    # an association for all objects retrieved from the same dataset
-    # without calling +eager+ on the dataset.  If you attempt to load
-    # associated objects for a record and the association for that
-    # object is currently not cached, it assumes you want to get
-    # the associated objects for all objects retrieved with the dataset that
-    # retrieved the current object.
-    #
-    # Tactical eager loading only takes affect if you retrieved the
-    # current object with Dataset#all, it doesn't work if you
-    # retrieved the current object with Dataset#each.
-    #
-    # Basically, this allows the following code to issue only two queries:
-    #
-    #   Album.where{id<100}.all do |a|
-    #     a.artists
-    #   end
-    #   # SELECT * FROM albums WHERE (id < 100)
-    #   # SELECT * FROM artists WHERE id IN (...)
-    #
-    # Note that if you are passing a callback to the association method via
-    # a block or :callback option, or using the :reload option to reload
-    # the association, eager loading will not be done.
-    #
-    # You can use the :eager_reload option to reload the association for all
-    # objects that the current object was retrieved with:
-    #
-    #   # SELECT * FROM albums WHERE (id < 100)
-    #   albums = Album.where{id<100}.all
-    #
-    #   # Eagerly load all artists for these albums
-    #   # SELECT * FROM artists WHERE id IN (...)
-    #   albums.first.artists
-    #
-    #   # Do something that may affect which artists are associated to the albums
-    #
-    #   # Eagerly reload all artists for these albums
-    #   # SELECT * FROM artists WHERE id IN (...)
-    #   albums.first.artists(eager_reload: true)
-    # 
-    # You can also use the :eager option to specify dependent associations
-    # to eager load:
-    #
-    #  albums = Album.where{id<100}.all
-    #
-    #   # Eager load all artists for these albums, and all albums for those artists
-    #   # SELECT * FROM artists WHERE id IN (...)
-    #   # SELECT * FROM albums WHERE artist_id IN (...)
-    #   albums.first.artists(eager: :albums)
-    #
-    # You can also use :eager to specify an eager callback. For example:
-    #
-    #   albums = Album.where{id<100}.all
-    #
-    #   # Eagerly load all artists whose name starts with A-M for these albums
-    #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)
-    #   albums.first.artists(eager: lambda{|ds| ds.where(Sequel[:name] > 'N')})
-    #
-    # Note that the :eager option only takes effect if the association
-    # has not already been loaded for the model.
-    #
-    # The tactical_eager_loading plugin also allows transparent eager
-    # loading when calling association methods on associated objects
-    # eagerly loaded via Dataset#eager_graph.  This can reduce N queries
-    # to a single query when iterating over all associated objects.
-    # Consider the following code:
-    #
-    #   artists = Artist.eager_graph(:albums).all
-    #   artists.each do |artist|
-    #     artist.albums.each do |album|
-    #       album.tracks
-    #     end
-    #   end
-    #
-    # By default this will issue a single query to load the artists and
-    # albums, and then one query for each album to load the tracks for
-    # the album:
-    #
-    #   # SELECT artists.id, ...
-    #            albums.id, ...
-    #   # FROM artists
-    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
-    #   # SELECT * FROM tracks WHERE album_id = 1;
-    #   # SELECT * FROM tracks WHERE album_id = 2;
-    #   # SELECT * FROM tracks WHERE album_id = 10;
-    #   # ...
-    #
-    # With the tactical_eager_loading plugin, this uses the same
-    # query to load the artists and albums, but then issues a single query
-    # to load the tracks for all albums.
-    #
-    #   # SELECT artists.id, ...
-    #            albums.id, ...
-    #   # FROM artists
-    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
-    #   # SELECT * FROM tracks WHERE (tracks.album_id IN (1, 2, 10, ...));
-    #
-    # Note that transparent eager loading for associated objects
-    # loaded by eager_graph will only take place if the associated classes
-    # also use the tactical_eager_loading plugin.
-    #
-    # When using this plugin, calling association methods on separate
-    # instances of the same result set is not thread-safe, because this
-    # plugin attempts to modify all instances of the same result set
-    # to eagerly set the associated objects, and having separate threads
-    # modify the same model instance is not thread-safe.
-    #
-    # Usage:
-    #
-    #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
-    #   Sequel::Model.plugin :tactical_eager_loading
-    #
-    #   # Make the Album class use tactical eager loading
-    #   Album.plugin :tactical_eager_loading
-    module TacticalEagerLoading
-      module InstanceMethods
-        # The dataset that retrieved this object, set if the object was
-        # reteived via Dataset#all.
-        attr_accessor :retrieved_by
-
-        # All model objects retrieved with this object, set if the object was
-        # reteived via Dataset#all.
-        attr_accessor :retrieved_with
-
-        # Remove retrieved_by and retrieved_with when marshalling.  retrieved_by
-        # contains unmarshallable objects, and retrieved_with can be very large
-        # and is not helpful without retrieved_by.
-        def marshallable!
-          @retrieved_by = nil
-          @retrieved_with = nil
-          super
-        end
-
-        private
-
-        # If there the association is not in the associations cache and the object
-        # was reteived via Dataset#all, eagerly load the association for all model
-        # objects retrieved with the current object.
-        def load_associated_objects(opts, dynamic_opts=OPTS, &block)
-          dynamic_opts = load_association_objects_options(dynamic_opts, &block)
-          name = opts[:name]
-          eager_reload = dynamic_opts[:eager_reload]
-          if (!associations.include?(name) || eager_reload) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
-            begin
-              objects = if eager_reload
-                retrieved_with.reject(&:frozen?)
-              else
-                retrieved_with.reject{|x| x.frozen? || x.associations.include?(name)}
-              end
-              retrieved_by.send(:eager_load, objects, name=>dynamic_opts[:eager] || OPTS)
-            rescue Sequel::UndefinedAssociation
-              # This can happen if class table inheritance is used and the association
-              # is only defined in a subclass.  This particular instance can use the
-              # association, but it can't be eagerly loaded as the parent class doesn't
-              # have access to the association, and that's the class doing the eager loading.
-              nil
-            end
-          end
-          super
-        end
-      end
-
-      module DatasetMethods
-        private
-
-        # Set the retrieved_with and retrieved_by attributes for each of the associated objects
-        # created by the eager graph loader with the appropriate class dataset and array of objects.
-        def _eager_graph_build_associations(_, egl)
-          objects = super
-
-          master = egl.master
-          egl.records_map.each do |k, v|
-            next if k == master || v.empty?
-
-            by = opts[:graph][:table_aliases][k]
-            values = v.values
-
-            values.each do |o|
-              next unless o.is_a?(TacticalEagerLoading::InstanceMethods) && !o.retrieved_by
-              o.retrieved_by = by
-              o.retrieved_with = values
-            end
-          end
-
-          objects
-        end
-
-        # Set the retrieved_with and retrieved_by attributes for each object
-        # with the current dataset and array of all objects.
-        def post_load(objects)
-          super
-          objects.each do |o|
-            next unless o.is_a?(Sequel::Model)
-            o.retrieved_by = self
-            o.retrieved_with = objects
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.56.0/lib/sequel/version.rb

@@ -1,25 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  # The major version of Sequel.  Only bumped for major changes.
-  MAJOR = 5
-
-  # The minor version of Sequel.  Bumped for every non-patch level
-  # release, generally around once a month.
-  MINOR = 56
-
-  # The tiny version of Sequel.  Usually 0, only bumped for bugfix
-  # releases that fix regressions from previous versions.
-  TINY  = 0
-  
-  # The version of Sequel you are using, as a string (e.g. "2.11.0")
-  VERSION = [MAJOR, MINOR, TINY].join('.').freeze
-
-  # The version of Sequel you are using, as a number (2.11.0 -> 20110)
-  VERSION_NUMBER = MAJOR*10000 + MINOR*10 + TINY
-  
-  # The version of Sequel you are using, as a string (e.g. "2.11.0")
-  def self.version
-    VERSION
-  end
-end