serrano-vk 0.1.0

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

@@ -0,0 +1,126 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The lazy_attributes plugin allows users to easily set that some attributes
+    # should not be loaded by default when loading model objects.  If the attribute
+    # is needed after the instance has been retrieved, a database query is made to
+    # retreive the value of the attribute.
+    #
+    # This plugin depends on the tactical_eager_loading plugin, and allows you to
+    # eagerly load lazy attributes for all objects retrieved with the current object.
+    # So the following code should issue one query to get the albums and one query to
+    # get the reviews for all of those albums:
+    #
+    #   Album.plugin :lazy_attributes, :review
+    #   Album.where{id < 100}.all do |a|
+    #     a.review
+    #   end
+    #
+    #   # You can specify multiple columns to lazily load:
+    #   Album.plugin :lazy_attributes, :review, :tracklist
+    #
+    # Note that by default on databases that supporting RETURNING,
+    # using explicit column selections will cause instance creations
+    # to use two queries (insert and refresh) instead of a single
+    # query using RETURNING.  You can use the insert_returning_select
+    # plugin to automatically use RETURNING for instance creations
+    # for models using the lazy_attributes plugin.
+    module LazyAttributes
+      # Lazy attributes requires the tactical_eager_loading plugin
+      def self.apply(model, *attrs)
+        model.plugin :tactical_eager_loading  
+      end
+      
+      # Set the attributes given as lazy attributes
+      def self.configure(model, *attrs)
+        model.lazy_attributes(*attrs) unless attrs.empty?
+      end
+      
+      module ClassMethods
+        # Freeze lazy attributes module when freezing model class.
+        def freeze
+          @lazy_attributes_module.freeze if @lazy_attributes_module
+
+          super
+        end
+
+        # Remove the given attributes from the list of columns selected by default.
+        # For each attribute given, create an accessor method that allows a lazy
+        # lookup of the attribute.  Each attribute should be given as a symbol.
+        def lazy_attributes(*attrs)
+          unless select = dataset.opts[:select]
+            select = dataset.columns.map{|c| Sequel.qualify(dataset.first_source, c)}
+          end
+          db_schema = @db_schema
+          set_dataset(dataset.select(*select.reject{|c| attrs.include?(dataset.send(:_hash_key_symbol, c))}))
+          @db_schema = db_schema
+          attrs.each{|a| define_lazy_attribute_getter(a)}
+        end
+        
+        private
+
+        # Add a lazy attribute getter method to the lazy_attributes_module. Options:
+        # :dataset :: The base dataset to use for the lazy attribute lookup
+        # :table :: The table name to use to qualify the attribute and primary key columns.
+        def define_lazy_attribute_getter(a, opts=OPTS)
+          include(@lazy_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@lazy_attributes_module"}) unless @lazy_attributes_module
+          @lazy_attributes_module.class_eval do
+            define_method(a) do
+              if !values.has_key?(a) && !new?
+                lazy_attribute_lookup(a, opts)
+              else
+                super()
+              end
+            end
+            alias_method(a, a)
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # If the model was selected with other model objects, eagerly load the
+        # attribute for all of those objects.  If not, query the database for
+        # the attribute for just the current object.  Return the value of
+        # the attribute for the current object.
+        def lazy_attribute_lookup(a, opts=OPTS)
+          table = opts[:table] || model.table_name
+          selection = Sequel.qualify(table, a)
+
+          if base_ds = opts[:dataset]
+            ds = base_ds.where(qualified_pk_hash(table))
+          else
+            base_ds = model.dataset
+            ds = this
+          end
+
+          if frozen?
+            return ds.get(selection)
+          end
+
+          if retrieved_with
+            primary_key = model.primary_key
+            composite_pk = true if primary_key.is_a?(Array)
+            id_map = {}
+            retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
+            predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
+            base_ds.
+             select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).
+             where(predicate_key=>id_map.keys).
+             naked.
+             each do |row|
+              obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
+              if obj && !obj.values.has_key?(a)
+                obj.values[a] = row[a]
+              end
+            end
+          end
+          values[a] = ds.get(selection) unless values.has_key?(a)
+          values[a]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+# 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.  You will need to provide a <tt>:scope</tt> option if
+    # the model's dataset uses a subquery (such as when using the class_table_inheritance
+    # plugin).
+    # 
+    # 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. If the list is empty, the position will
+        # be set to the model's +top_of_list+ value.
+        def before_validation
+          unless get_column_value(position_field)
+            current_max = list_dataset.max(position_field)
+            value = current_max.nil? ? model.top_of_list : current_max.to_i + 1
+            set_column_value("#{position_field}=", value)
+          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