serrano-vk 0.1.0

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

@@ -0,0 +1,113 @@
+# frozen-string-literal: true
+#
+# The index_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump information about database indexes to a file,
+# and load it from that file.  Loading index 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 index.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+# Then, whenever database indicies are modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -X option:
+#
+#   bin/sequel -X /path/to/index_cache.dump postgres://...
+#
+# Alternatively, if you don't want to dump the index 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 :index_caching
+#   DB.load_index_cache?('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+#   DB.dump_index_cache?('/path/to/index_cache.dump')
+#
+# With this method, you just have to delete the index 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
+# index cache 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 index cache is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the indexes hash.  Because of this,
+# you should not attempt to load from an untrusted file.
+#
+# Related module: Sequel::IndexCaching
+
+#
+module Sequel
+  module IndexCaching
+    # Set index cache to the empty hash.
+    def self.extended(db)
+      db.instance_variable_set(:@indexes, {})
+    end
+    
+    # Dump the index cache to the filename given in Marshal format.
+    def dump_index_cache(file)
+      indexes = {}
+      @indexes.sort.each do |k, v|
+        indexes[k] = v
+      end
+      File.open(file, 'wb'){|f| f.write(Marshal.dump(indexes))}
+      nil
+    end
+
+    # Dump the index cache to the filename given unless the file
+    # already exists.
+    def dump_index_cache?(file)
+      dump_index_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the index cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_index_cache(file)
+      @indexes = Marshal.load(File.read(file))
+      nil
+    end
+
+    # Replace the index cache with the data from the given file if the
+    # file exists.
+    def load_index_cache?(file)
+      load_index_cache(file) if File.exist?(file)
+    end
+
+    # If no options are provided and there is cached index information for
+    # the table, return the cached information instead of querying the
+    # database.
+    def indexes(table, opts=OPTS)
+      return super unless opts.empty?
+
+      quoted_name = literal(table)
+      if v = Sequel.synchronize{@indexes[quoted_name]}
+        return v
+      end
+
+      result = super
+      Sequel.synchronize{@indexes[quoted_name] = result}
+      result
+    end
+
+    private
+
+    # Remove the index cache for the given schema name
+    def remove_cached_schema(table)
+      k = quote_schema_table(table)
+      Sequel.synchronize{@indexes.delete(k)}
+      super
+    end
+  end
+
+  Database.register_extension(:index_caching, IndexCaching)
+end

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

@@ -0,0 +1,258 @@
+# frozen-string-literal: true
+#
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
+#
+# To load the extension:
+#
+#   Sequel.extension :inflector
+#
+# Related module: String::Inflections
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    require_relative '../model/default_inflections'
+    instance_exec(&Sequel::DEFAULT_INFLECTIONS_PROC)
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if defined?(yield)
+    Inflections
+  end
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
+
+  # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
+  # is set to :lower then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    tr('_', '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_underscore+ sets whether the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    gsub(/_id$/, "").tr('_', " ").capitalize
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+#
+# The integer64 extension changes the default type used for Integer
+# to be the same type as used for :Bignum.  In general, this means that
+# instead of Integer resulting in a 32-bit database integer type, it will
+# result in a 64-bit database integer type.  This affects the default
+# type used for primary_key and foreign_key when using the schema
+# modification methods.
+#
+# Note that it doesn't make sense to use this extension on SQLite, since
+# the integer type will automatically handle 64-bit integers, and it treats
+# the integer type specially when the column is also the primary key.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :integer64
+#
+# Related module: Sequel::Integer64
+
+#
+module Sequel
+  module Integer64
+    private
+
+    # Use same type as used for :Bignum by default for generic integer value.
+    def type_literal_generic_integer(column)
+      type_literal_generic_bignum_symbol(column)
+    end
+  end
+
+  Database.register_extension(:integer64, Integer64)
+end

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

@@ -0,0 +1,141 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          when :sqlite
+            db.sqlite_version >= 33900
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

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

@@ -0,0 +1,50 @@
+# frozen-string-literal: true
+#
+# The LooserTypecasting extension loosens the default database typecasting
+# for the following types:
+#
+# :float :: use to_f instead of Float()
+# :integer :: use to_i instead of Integer()
+# :decimal :: use 0.0 for unsupported strings
+# :string :: silently allow hash and array conversion to string
+#
+# This also removes bytesize checks for string inputs for float, integer
+# and decimal conversions.
+#
+# To load the extension into the database:
+#
+#   DB.extension :looser_typecasting
+#
+# Related module: Sequel::LooserTypecasting
+
+#
+module Sequel
+  module LooserTypecasting
+    private
+
+    # Typecast the value to a Float using to_f instead of Kernel.Float
+    def typecast_value_float(value)
+      value.to_f
+    end
+
+    # Typecast the value to an Integer using to_i instead of Kernel.Integer
+    def typecast_value_integer(value)
+      value.to_i
+    end
+
+    # Typecast the value to an String using to_s instead of Kernel.String
+    def typecast_value_string(value)
+      value.to_s
+    end
+
+    # Typecast invalid BigDecimal to 0.0.
+    def _typecast_value_string_to_decimal(value)
+      BigDecimal(value)
+    rescue
+      BigDecimal('0.0')
+    end
+  end
+
+  Database.register_extension(:looser_typecasting, LooserTypecasting)
+end
+