serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/query.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+#
+# The query extension adds a query method which allows
+# a different way to construct queries instead of the usual
+# method chaining:
+#
+#   dataset = DB[:items].query do
+#     select :x, :y, :z
+#     where{(x > 1) & (y > 2)}
+#     reverse :z
+#   end
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:query)
+#
+# Or you can load it into all of a database's datasets, which
+# is probably the desired behavior if you are using this extension:
+#
+#   DB.extension(:query)
+#
+# Related modules: Sequel::DatabaseQuery, Sequel::DatasetQuery,
+# Sequel::Dataset::Query
+
+#
+module Sequel
+  module DatabaseQuery
+    def self.extended(db)
+      db.extend_datasets(DatasetQuery)
+    end
+
+    # Return a dataset modified by the query block
+    def query(&block)
+      dataset.query(&block)
+    end
+  end
+
+  module DatasetQuery
+    # Translates a query block into a dataset. Query blocks are an
+    # alternative to Sequel's usual method chaining, by using
+    # instance_exec with a proxy object:
+    #
+    #   dataset = DB[:items].query do
+    #     select :x, :y, :z
+    #     where{(x > 1) & (y > 2)}
+    #     reverse :z
+    #   end
+    #
+    # Which is the same as:
+    #
+    #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
+    def query(&block)
+      query = Dataset::Query.new(self)
+      query.instance_exec(&block)
+      query.dataset
+    end
+  end
+
+  class Dataset
+    # Proxy object used by Dataset#query.
+    class Query < Sequel::BasicObject
+      # The current dataset in the query.  This changes on each method call.
+      attr_reader :dataset
+     
+      def initialize(dataset)
+        @dataset = dataset
+      end
+
+      # Replace the query's dataset with dataset returned by the method call.
+      def method_missing(method, *args, &block)
+        # Allow calling private methods, so things like raise works
+        @dataset = @dataset.send(method, *args, &block)
+        raise(Sequel::Error, "method #{method.inspect} did not return a dataset") unless @dataset.is_a?(Dataset)
+        self
+      end
+      # :nocov:
+      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
+    end
+  end
+
+  Dataset.register_extension(:query, DatasetQuery)
+  Database.register_extension(:query, DatabaseQuery)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/query_blocker.rb

@@ -0,0 +1,172 @@
+# frozen-string-literal: true
+#
+# The query_blocker extension adds Database#block_queries.
+# Inside the block passed to #block_queries, any attempts to
+# execute a query/statement on the database will raise a
+# Sequel::QueryBlocker::BlockedQuery exception.
+#
+#   DB.extension :query_blocker
+#   DB.block_queries do
+#     ds = DB[:table]          # No exception
+#     ds = ds.where(column: 1) # No exception
+#     ds.all                   # Exception raised
+#   end
+#
+# To handle concurrency, you can pass a :scope option:
+#
+#   # Current Thread
+#   DB.block_queries(scope: :thread){}
+#
+#   # Current Fiber
+#   DB.block_queries(scope: :fiber){}
+#
+#   # Specific Thread
+#   DB.block_queries(scope: Thread.current){}
+#
+#   # Specific Fiber
+#   DB.block_queries(scope: Fiber.current){}
+#
+# Database#block_queries is useful for blocking queries inside
+# the block.  However, there may be cases where you want to
+# allow queries in specific places inside a block_queries block.
+# You can use Database#allow_queries for that:
+#
+#   DB.block_queries do
+#     DB.allow_queries do
+#       DB[:table].all           # Query allowed
+#     end
+#
+#     DB[:table].all           # Exception raised
+#   end
+#
+# When mixing block_queries and allow_queries with scopes, the
+# narrowest scope has priority.  So if you are blocking with
+# :thread scope, and allowing with :fiber scope, queries in the
+# current fiber will be allowed, but queries in different fibers of
+# the current thread will be blocked.
+#
+# Note that this should catch all queries executed through the
+# Database instance.  Whether it catches queries executed directly
+# on a connection object depends on the adapter in use.
+#
+# Related module: Sequel::QueryBlocker
+
+require "fiber"
+
+#
+module Sequel
+  module QueryBlocker
+    # Exception class raised if there is an attempt to execute a 
+    # query/statement on the database inside a block passed to
+    # block_queries.
+    class BlockedQuery < Sequel::Error
+    end
+
+    def self.extended(db)
+      db.instance_exec do
+        @blocked_query_scopes ||= {}
+      end
+    end
+
+    # If checking a connection for validity, and a BlockedQuery exception is
+    # raised, treat it as a valid connection.  You cannot check whether the
+    # connection is valid without issuing a query, and if queries are blocked,
+    # you need to assume it is valid or assume it is not.  Since it most cases
+    # it will be valid, this assumes validity.
+    def valid_connection?(conn)
+      super
+    rescue BlockedQuery
+      true
+    end
+
+    # Check whether queries are blocked before executing them.
+    def log_connection_yield(sql, conn, args=nil)
+      # All database adapters should be calling this method around
+      # query execution (otherwise the queries would not get logged),
+      # ensuring the blocking is checked.  Any database adapter issuing
+      # a query without calling this method is considered buggy.
+      check_blocked_queries!
+      super
+    end
+
+    # Whether queries are currently blocked.
+    def block_queries?
+      b = @blocked_query_scopes
+      b.fetch(Fiber.current) do
+        b.fetch(Thread.current) do
+          b.fetch(:global, false)
+        end
+      end
+    end
+
+    # Allow queries inside the block.  Only useful if they are already blocked
+    # for the same scope. Useful for blocking queries generally, and only allowing
+    # them in specific places.  Takes the same :scope option as #block_queries.
+    def allow_queries(opts=OPTS, &block)
+      _allow_or_block_queries(false, opts, &block)
+    end
+
+    # Reject (raise an BlockedQuery exception) if there is an attempt to execute
+    # a query/statement inside the block.
+    #
+    # The :scope option indicates which queries are rejected inside the block:
+    #
+    # :global :: This is the default, and rejects all queries.
+    # :thread :: Reject all queries in the current thread.
+    # :fiber :: Reject all queries in the current fiber.
+    # Thread :: Reject all queries in the given thread.
+    # Fiber :: Reject all queries in the given fiber.
+    def block_queries(opts=OPTS, &block)
+      _allow_or_block_queries(true, opts, &block)
+    end
+    
+    private
+
+    # Internals of block_queries and allow_queries.
+    def _allow_or_block_queries(value, opts)
+      scope = query_blocker_scope(opts)
+      prev_value = nil
+      scopes = @blocked_query_scopes
+
+      begin
+        Sequel.synchronize do
+          prev_value = scopes[scope]
+          scopes[scope] = value
+        end
+
+        yield
+      ensure
+        Sequel.synchronize do
+          if prev_value.nil?
+            scopes.delete(scope)
+          else
+            scopes[scope] = prev_value
+          end
+        end
+      end
+    end
+
+    # The scope for the query block, either :global, or a Thread or Fiber instance.
+    def query_blocker_scope(opts)
+      case scope = opts[:scope]
+      when nil
+        :global
+      when :global, Thread, Fiber
+        scope
+      when :thread
+        Thread.current
+      when :fiber
+        Fiber.current
+      else
+        raise Sequel::Error, "invalid scope given to block_queries: #{scope.inspect}"
+      end
+    end
+
+    # Raise a BlockQuery exception if queries are currently blocked.
+    def check_blocked_queries!
+      raise BlockedQuery, "cannot execute query inside a block_queries block" if block_queries?
+    end
+  end
+
+  Database.register_extension(:query_blocker, QueryBlocker)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/round_timestamps.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+#
+# The round_timestamps extension will automatically round timestamp
+# values to the database's supported level of precision before literalizing
+# them.
+#
+# For example, if the database supports millisecond precision, and you give
+# it a Time value with microsecond precision, it will round it appropriately:
+#
+#   Time.at(1405341161.917999982833862)
+#   # default: 2014-07-14 14:32:41.917999
+#   # with extension: 2014-07-14 14:32:41.918000
+#
+# The round_timestamps extension correctly deals with databases that support
+# millisecond or second precision.  In addition to handling Time values, it
+# also handles DateTime values and Sequel::SQLTime values (for the TIME type).
+#
+# To round timestamps for a single dataset:
+#
+#   ds = ds.extension(:round_timestamps)
+#
+# To round timestamps for all datasets on a single database:
+#
+#   DB.extension(:round_timestamps)
+#
+# Related module: Sequel::Dataset::RoundTimestamps
+
+module Sequel
+  class Dataset
+    module RoundTimestamps
+      # Round DateTime values before literalizing
+      def literal_datetime(v)
+        super(v + Rational(5, 10**timestamp_precision)/864000)
+      end
+
+      # Round Sequel::SQLTime values before literalizing
+      def literal_sqltime(v)
+        super(v.round(sqltime_precision))
+      end
+
+      # Round Time values before literalizing
+      def literal_time(v)
+        super(v.round(timestamp_precision))
+      end
+    end
+
+    register_extension(:round_timestamps, RoundTimestamps)
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/run_transaction_hooks.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+#
+# The run_transaction_hooks extension allows for running after_commit or
+# after_rollback extensions before commit or rollback.  It then removes
+# the hook after running it, so it will not be run twice.
+#
+# This extension should only be used in transactional tests where the
+# transaction always rolls back, to test the behavior of the after_commit
+# and after_rollback hooks.  Any other usage is probably a bad idea.
+#
+# Example:
+#
+#   DB.extension :run_transaction_hooks
+#   x = 1
+#   DB.transaction(rollback: :always) do
+#     DB.after_rollback{x = 3}
+#     DB.after_commit{x = 2}
+#
+#     x # => 1
+#     DB.run_after_rollback_hooks
+#     x # => 3
+#     DB.run_after_commit_hooks
+#     x # => 2
+#   end
+#   x # => 2
+
+#
+class Sequel::Database
+  module RunTransactionHooks
+    # Run all savepoint and transaction after_commit hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_commit_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_commit, opts)
+    end
+
+    # Run all savepoint and transaction after_rollback hooks for the current transaction,
+    # and remove the hooks after running them.
+    # Options:
+    # :server :: The server/shard to use.
+    def run_after_rollback_hooks(opts=OPTS)
+      _run_transaction_hooks(:after_rollback, opts)
+    end
+
+    private
+
+    def _run_transaction_hooks(type, opts)
+      synchronize(opts[:server]) do |conn|
+        unless h = _trans(conn)
+          raise Sequel::Error, "Cannot call run_#{type}_hooks outside of a transaction"
+        end
+
+        if hooks = h[type]
+          hooks.each(&:call)
+          hooks.clear
+        end
+
+        if (savepoints = h[:savepoints])
+          savepoints.each do |savepoint|
+            if hooks = savepoint[type]
+              hooks.each(&:call)
+              hooks.clear
+            end
+          end
+        end
+      end
+    end
+  end
+
+  register_extension(:run_transaction_hooks, RunTransactionHooks)
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/s.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+#
+# The s extension adds Sequel::S, a module containing a private #S
+# method that calls Sequel.expr.  It's designed as a shortcut so
+# that instead of:
+#
+#   Sequel.expr(:column) + 1
+#   # or
+#   Sequel.expr{column + 1}
+#
+# you can just write:
+#
+#   S(:column) + 1
+#   # or
+#   S{column + 1}
+#
+# To load the extension:
+#
+#   Sequel.extension :s
+#
+# Then you can include the Sequel::S module into whatever classes or
+# objects you care about:
+#
+#   Sequel::Model.send(:include, Sequel::S)   # available in model instance methods
+#   Sequel::Model.extend(Sequel::S)           # available in model class methods
+#   Sequel::Dataset.send(:include, Sequel::S) # available in dataset methods
+#
+# or just into Object if you want it available everywhere:
+#
+#   Object.send(:include, Sequel::S)
+#
+# If you are using Ruby 2+, and you would like to use refinements, you
+# can use Sequel::S as a refinement, in which case the private #S method
+# will be available on all objects while the refinement is active.
+#
+#   using Sequel::S
+#
+#   S(:column) + 1
+#
+# Related module: Sequel::S
+
+
+# 
+module Sequel::S
+  private
+
+  # Delegate to Sequel.expr
+  def S(*a, &block)
+    Sequel.expr(*a, &block)
+  end
+
+  # :nocov:
+  if RUBY_VERSION >= '2.0.0'
+    include_meth = RUBY_VERSION >= '3.1' ? :import_methods : :include
+  # :nocov:
+    refine Object do
+      send include_meth, Sequel::S
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/extensions/schema_caching.rb

@@ -0,0 +1,103 @@
+# frozen-string-literal: true
+#
+# The schema_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump the parsed schema information to a file,
+# and load it from that file.  Loading the schema information from a
+# dumped file is faster than parsing it from the database, so this
+# can save bootup time for applications with large numbers of models.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :schema_caching
+#   DB.load_schema_cache('/path/to/schema.dump')
+#
+#   # load model files
+#
+# Then, whenever the database schema is modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -S option:
+#
+#   bin/sequel -S /path/to/schema.dump postgres://...
+#
+# Alternatively, if you don't want to dump the schema information for
+# all tables, and you don't worry about race conditions, you can
+# choose to use the following in your application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :schema_caching
+#   DB.load_schema_cache?('/path/to/schema.dump')
+#
+#   # load model files
+#
+#   DB.dump_schema_cache?('/path/to/schema.dump')
+#
+# With this method, you just have to delete the schema dump file if
+# the schema is modified, and the application will recreate it for you
+# using just the tables that your models use.
+#
+# Note that it is up to the application to ensure that the dumped
+# cached schema reflects the current state of the database.  Sequel
+# does no checking to ensure this, as checking would take time and the
+# purpose of this code is to take a shortcut.
+#
+# The cached schema is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the schema hash.  Because of this,
+# you should not attempt to load the schema from a untrusted file.
+#
+# Related module: Sequel::SchemaCaching
+
+#
+module Sequel
+  module SchemaCaching
+    # Dump the cached schema to the filename given in Marshal format.
+    def dump_schema_cache(file)
+      sch = dumpable_schema_cache
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(sch))}
+      nil
+    end
+
+    # Dump the cached schema to the filename given unless the file
+    # already exists.
+    def dump_schema_cache?(file)
+      dump_schema_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the schema cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_schema_cache(file)
+      @schemas = load_schema_cache_file(file)
+      @schemas.each_value{|v| schema_post_process(v)}
+      nil
+    end
+
+    # Replace the schema cache with the data from the given file if the
+    # file exists.
+    def load_schema_cache?(file)
+      load_schema_cache(file) if File.exist?(file)
+    end
+
+    private
+
+    # Return the deserialized schema cache file.
+    def load_schema_cache_file(file)
+      Marshal.load(File.read(file))
+    end
+
+    # A dumpable version of the schema cache.
+    def dumpable_schema_cache
+      sch = {}
+
+      @schemas.sort.each do |k,v|
+        sch[k] = v.map do |c, h|
+          h = Hash[h]
+          h.delete(:callable_default)
+          [c, h]
+        end
+      end
+
+      sch
+    end
+  end
+
+  Database.register_extension(:schema_caching, SchemaCaching)
+end