serrano-vk 0.1.0

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

@@ -0,0 +1,185 @@
+# frozen-string-literal: true
+#
+# The eval_inspect extension changes #inspect for Sequel::SQL::Expression
+# subclasses to return a string suitable for ruby's eval, such that
+#
+#   eval(obj.inspect) == obj
+#
+# is true.  The above code is true for most of ruby's simple classes such
+# as String, Integer, Float, and Symbol, but it's not true for classes such
+# as Time, Date, and BigDecimal.  Sequel attempts to handle situations where
+# instances of these classes are a component of a Sequel expression.
+#
+# To load the extension:
+#
+#   Sequel.extension :eval_inspect
+#
+# Related module: Sequel::EvalInspect
+
+#
+module Sequel
+  module EvalInspect
+    # Special case objects where inspect does not generally produce input
+    # suitable for eval.  Used by Sequel::SQL::Expression#inspect so that
+    # it can produce a string suitable for eval even if components of the
+    # expression have inspect methods that do not produce strings suitable
+    # for eval.
+    def eval_inspect(obj)
+      case obj
+      when BigDecimal
+        "Kernel::BigDecimal(#{obj.to_s.inspect})"
+      when Sequel::SQL::Blob, Sequel::LiteralString
+        "#{obj.class}.new(#{obj.to_s.inspect})"
+      when Sequel::SQL::ValueList
+        "#{obj.class}.new(#{obj.to_a.inspect})"
+      when Array
+        "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Set
+        "Set[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
+      when Hash
+        "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
+      when Time
+        datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
+        "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
+      when DateTime
+        # Ignore date of calendar reform
+        "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
+      when Date
+        # Ignore offset and date of calendar reform
+        "Date.new(#{obj.year}, #{obj.month}, #{obj.day})"
+      else
+        obj.inspect
+      end
+    end
+  end
+
+  extend EvalInspect
+
+  module SQL
+    class Expression
+      alias inspect inspect
+
+      # Attempt to produce a string suitable for eval, such that:
+      #
+      #   eval(obj.inspect) == obj
+      def inspect
+        # Assume by default that the object can be recreated by calling
+        # self.class.new with any attr_reader values defined on the class,
+        # in the order they were defined.
+        klass = self.class
+        args = inspect_args.map do |arg|
+          if arg.is_a?(String) && arg.start_with?('*')
+            # Special case string arguments starting with *, indicating that
+            # they should return an array to be splatted as the remaining arguments.
+            # Allow calling private methods to get inspect output.
+            send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
+          else
+            # Allow calling private methods to get inspect output.
+            Sequel.eval_inspect(send(arg))
+          end
+        end
+        "#{klass}.#{inspect_new_method}(#{args.join(', ')})"
+      end
+
+      private
+
+      # Which attribute values to use in the inspect string.
+      def inspect_args
+        self.class.comparison_attrs
+      end
+
+      # Use the new method by default for creating new objects.
+      def inspect_new_method
+        :new
+      end
+    end
+
+    class ComplexExpression
+      private
+
+      # ComplexExpression's initializer uses a splat for the operator arguments.
+      def inspect_args
+        [:op, "*args"]
+      end
+    end
+
+    class Constant
+      # Constants to lookup in the Sequel module.
+      INSPECT_LOOKUPS = [:CURRENT_DATE, :CURRENT_TIMESTAMP, :CURRENT_TIME, :SQLTRUE, :SQLFALSE, :NULL, :NOTNULL]
+
+      # Reference the constant in the Sequel module if there is
+      # one that matches.
+      def inspect
+        INSPECT_LOOKUPS.each do |c|
+          return "Sequel::#{c}" if Sequel.const_get(c) == self
+        end
+        super
+      end
+    end
+
+    class CaseExpression
+      private
+
+      # CaseExpression's initializer checks whether an argument was
+      # provided, to differentiate CASE WHEN from CASE NULL WHEN, so
+      # check if an expression was provided, and only include the
+      # expression in the inspect output if so.
+      def inspect_args
+        if expression?
+          [:conditions, :default, :expression]
+        else
+          [:conditions, :default]
+        end
+      end
+    end
+
+    class Function
+      private
+
+      # Function uses a new! method for creating functions with options,
+      # since Function.new does not allow for an options hash.
+      def inspect_new_method
+        :new!
+      end
+    end
+
+    class JoinOnClause
+      private
+
+      # JoinOnClause's initializer takes the on argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:on, :join_type, :table_expr] 
+      end
+    end
+
+    class JoinUsingClause
+      private
+
+      # JoinOnClause's initializer takes the using argument as the first argument
+      # instead of the last.
+      def inspect_args
+        [:using, :join_type, :table_expr] 
+      end
+    end
+
+    class OrderedExpression
+      private
+
+      # OrderedExpression's initializer takes the :nulls information inside a hash,
+      # so if a NULL order was given, include a hash with that information.
+      def inspect_args
+        if nulls
+          [:expression, :descending, :opts_hash]
+        else
+          [:expression, :descending]
+        end
+      end
+
+      # A hash of null information suitable for passing to the initializer.
+      def opts_hash
+        {:nulls=>nulls} 
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+#
+# The exclude_or_null extension adds Dataset#exclude_or_null and
+# Dataset#exclude_or_null_having.  These methods are similar to
+# Dataset#exclude and Dataset#exclude_having, except that they
+# will also exclude rows where the condition IS NULL.
+#
+#   DB[:table].exclude_or_null(foo: 1)
+#   # SELECT * FROM table WHERE NOT coalesce((foo = 1), false)
+#   
+#   DB[:table].exclude_or_null{foo(bar) =~ 1}
+#   # SELECT * FROM table HAVING NOT coalesce((foo(bar) = 1), false))
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:exclude_or_null)
+#
+# 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(:exclude_or_null)
+#
+# Note, this extension works correctly on PostgreSQL, SQLite, MySQL,
+# H2, and HSQLDB.  However, it does not work correctly on Microsoft SQL Server,
+# Oracle, DB2, SQLAnywhere, or Derby.
+#
+# Related module: Sequel::ExcludeOrNull
+
+#
+module Sequel
+  module ExcludeOrNull
+    # Performs the inverse of Dataset#where, but also excludes rows where the given
+    # condition IS NULL.
+    #
+    #   DB[:items].exclude_or_null(category: 'software')
+    #   # SELECT * FROM items WHERE NOT coalesce((category = 'software'), false)
+    #   
+    #   DB[:items].exclude_or_null(category: 'software', id: 3)
+    #   # SELECT * FROM items WHERE NOT coalesce(((category = 'software') AND (id = 3)), false)
+    def exclude_or_null(*cond, &block)
+      add_filter(:where, cond, :or_null, &block)
+    end
+
+    # The same as exclude_or_null, but affecting the HAVING clause instead of the
+    # WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_or_null_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING NOT coalesce((count(name) < 2), true)
+    def exclude_or_null_having(*cond, &block)
+      add_filter(:having, cond, :or_null, &block)
+    end
+
+    private
+
+    # Recognize :or_null value for invert, returning an expression for
+    # the invert of the condition or the condition being null.
+    def _invert_filter(cond, invert)
+      if invert == :or_null
+        ~SQL::Function.new(:coalesce, cond, SQL::Constants::SQLFALSE)
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:exclude_or_null, ExcludeOrNull)
+end

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

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+#
+# The fiber_concurrency extension changes the default concurrency
+# primitive in Sequel to be Fiber.current instead of Thread.current.
+# This is the value used in various hash keys to implement safe
+# concurrency (thread-safe concurrency by default, fiber-safe
+# concurrency with this extension.  It can be enabled via:
+#
+#   Sequel.extension :fiber_concurrency
+#   
+# Related module: Sequel::FiberConcurrency
+
+require 'fiber'
+
+module Sequel
+  module FiberConcurrency
+    # Make the current concurrency primitive be Fiber.current.
+    def current
+      Fiber.current
+    end
+  end
+
+  extend FiberConcurrency
+end

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

@@ -0,0 +1,3 @@
+# frozen-string-literal: true
+
+Sequel::Database.register_extension(:freeze_datasets){}

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

@@ -0,0 +1,3 @@
+# frozen-string-literal: true
+
+Sequel::Database.register_extension(:from_block){}

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

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+#
+# The graph_each extension adds Dataset#graph_each and
+# makes Dataset#each call #graph_each if the dataset has been graphed.
+# Dataset#graph_each splits result hashes into subhashes per table:
+#
+#   DB[:a].graph(:b, id: :b_id).all
+#   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:graph_each)
+#
+# 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(:graph_each)
+#
+# Related module: Sequel::GraphEach
+
+#
+module Sequel
+  module GraphEach
+    # Call graph_each for graphed datasets that are not being eager graphed.
+    def each
+      if @opts[:graph] && !@opts[:eager_graph]
+        graph_each{|r| yield r}
+      else
+        super
+      end
+    end
+
+    # Call graph_each for graphed datasets that are not being eager graphed.
+    def with_sql_each(sql)
+      if @opts[:graph] && !@opts[:eager_graph]
+        graph_each(sql){|r| yield r}
+      else
+        super
+      end
+    end
+
+    private
+
+    # Fetch the rows, split them into component table parts,
+    # tranform and run the row_proc on each part (if applicable),
+    # and yield a hash of the parts.
+    def graph_each(sql=select_sql)
+      # Reject tables with nil datasets, as they are excluded from
+      # the result set
+      datasets = @opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
+      # Get just the list of table aliases into a local variable, for speed
+      table_aliases = datasets.map{|ta,ds| ta}
+      # Get an array of arrays, one for each dataset, with
+      # the necessary information about each dataset, for speed
+      datasets = datasets.map{|ta, ds| [ta, ds, ds.row_proc]}
+      # Use the manually set graph aliases, if any, otherwise
+      # use the ones automatically created by .graph
+      column_aliases = @opts[:graph][:column_aliases]
+      fetch_rows(sql) do |r|
+        graph = {}
+        # Create the sub hashes, one per table
+        table_aliases.each{|ta| graph[ta]={}}
+        # Split the result set based on the column aliases
+        # If there are columns in the result set that are
+        # not in column_aliases, they are ignored
+        column_aliases.each do |col_alias, tc|
+          ta, column = tc
+          graph[ta][column] = r[col_alias]
+        end
+        # For each dataset run the row_proc if applicable
+        datasets.each do |ta,ds,rp|
+          g = graph[ta]
+          graph[ta] = if g.values.any?{|x| !x.nil?}
+            rp ? rp.call(g) : g
+          else
+            nil
+          end
+        end
+
+        yield graph
+      end
+      self
+    end
+  end
+
+  Dataset.register_extension(:graph_each, GraphEach)
+end

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

@@ -0,0 +1,180 @@
+# frozen-string-literal: true
+#
+# The identifier_mangling extension adds support for to change
+# the default identifier mangling for datasets, as well as all
+# datasets for a given database.
+#
+#   # Use uppercase identifiers in database, and lowercase in ruby.
+#   # Default behavior of Sequel, as the SQL standard behavior
+#   # folds unquoted identifiers to uppercase.
+#   DB.identifier_input_method = :upcase
+#   DB.identifier_output_method = :downcase
+#   
+#   # Don't modify identifiers.
+#   # Default behavior of Sequel on PostgreSQL, MySQL, SQLite,
+#   # as they fold unquoted identifiers to lowercase.
+#   DB.identifier_input_method = nil
+#   DB.identifier_output_method = nil
+#
+# You can also choose to turn on or off identifier quoting:
+#
+#   # Quote identifiers.  Sequel's default behavior.
+#   DB.quote_identifiers = true
+# 
+#   # Don't quote identifiers.  Sequel's default behavior on DB2.
+#   DB.quote_identifiers = false
+#   
+# To modify the identifiers on a per-dataset basis:
+#
+#   ds = DB[:a].with_input_indentifier(:upcase).
+#               with_output_identifier(:downcase).
+#               with_quote_identifiers(true)
+#
+# To load the extension into the database:
+#
+#   DB.extension :identifier_mangling
+#
+# Related modules: Sequel::IdentifierMangling::DatabaseMethods,
+# Sequel::IdentifierMangling::DatasetMethods
+
+#
+module Sequel
+  module IdentifierMangling
+    module DatabaseMethods
+      def self.extended(db)
+        db.instance_exec do
+          @identifier_input_method = nil
+          @identifier_output_method = nil
+          @quote_identifiers = nil
+          reset_identifier_mangling
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # The identifier input method to use by default for this database (default: adapter default)
+      attr_reader :identifier_input_method
+
+      # The identifier output method to use by default for this database (default: adapter default)
+      attr_reader :identifier_output_method
+
+      # Set the method to call on identifiers going into the database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.identifier_input_method = :upcase
+      #   DB[:items] # SELECT * FROM ITEMS
+      def identifier_input_method=(v)
+        reset_default_dataset
+        @identifier_input_method = v
+      end
+      
+      # Set the method to call on identifiers coming from the database:
+      #
+      #   DB[:items].first # {:id=>1, :name=>'foo'}
+      #   DB.identifier_output_method = :upcase
+      #   DB[:items].first # {:ID=>1, :NAME=>'foo'}
+      def identifier_output_method=(v)
+        reset_default_dataset
+        @identifier_output_method = v
+      end
+
+      # Set whether to quote identifiers (columns and tables) for this database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.quote_identifiers = true
+      #   DB[:items] # SELECT * FROM "items"
+      def quote_identifiers=(v)
+        reset_default_dataset
+        @quote_identifiers = v
+      end
+      
+      # Returns true if the database quotes identifiers.
+      def quote_identifiers?
+        @quote_identifiers
+      end
+
+      private
+
+      # Return a dataset that uses the default identifier input and output methods
+      # for this database.  Used when parsing metadata so that column symbols are
+      # returned as expected.
+      def _metadata_dataset
+        super.
+          with_identifier_input_method(identifier_input_method_default).
+          with_identifier_output_method(identifier_output_method_default)
+      end
+
+      # Upcase identifiers on input if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_input_method_default
+        return super if defined?(super)
+        :upcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Downcase identifiers on output if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_output_method_default
+        return super if defined?(super)
+        :downcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Reset the identifier mangling options.  Overrides any already set on
+      # the instance.  Only for internal use by shared adapters.
+      def reset_identifier_mangling
+        @quote_identifiers = @opts.fetch(:quote_identifiers, quote_identifiers_default)
+        @identifier_input_method = @opts.fetch(:identifier_input_method, identifier_input_method_default)
+        @identifier_output_method = @opts.fetch(:identifier_output_method, identifier_output_method_default)
+        reset_default_dataset
+      end
+    end
+
+    module DatasetMethods
+      # The String instance method to call on identifiers before sending them to
+      # the database.
+      def identifier_input_method
+        @opts.fetch(:identifier_input_method, db.identifier_input_method)
+      end
+      
+      # The String instance method to call on identifiers before sending them to
+      # the database.
+      def identifier_output_method
+        @opts.fetch(:identifier_output_method, db.identifier_output_method)
+      end
+    
+      # Check with the database to see if identifier quoting is enabled
+      def quote_identifiers?
+        @opts.fetch(:quote_identifiers, db.quote_identifiers?)
+      end
+
+      # Return a modified dataset with identifier_input_method set.
+      def with_identifier_input_method(meth)
+        clone(:identifier_input_method=>meth, :skip_symbol_cache=>true)
+      end
+      
+      # Return a modified dataset with identifier_output_method set.
+      def with_identifier_output_method(meth)
+        clone(:identifier_output_method=>meth)
+      end
+
+      private
+
+      # Convert the identifier to the version used in the database via
+      # identifier_input_method.
+      def input_identifier(v)
+        (i = identifier_input_method) ? v.to_s.public_send(i) : v.to_s
+      end
+
+      # Modify the identifier returned from the database based on the
+      # identifier_output_method.
+      def output_identifier(v)
+        v = 'untitled' if v == ''
+        (i = identifier_output_method) ? v.to_s.public_send(i).to_sym : v.to_sym
+      end
+
+      def non_sql_option?(key)
+        super || key == :identifier_input_method || key == :identifier_output_method
+      end
+    end
+  end
+
+  Database.register_extension(:identifier_mangling, IdentifierMangling::DatabaseMethods)
+end

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

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The implicit_subquery extension changes most dataset methods that
+# return modified datasets to implicitly call from_self if the database
+# currently uses raw SQL.  Sequel's by default does not do this:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT * FROM table"
+#
+# With this extension, datasets that use raw SQL are implicitly wrapped
+# in a subquery:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT column FROM (SELECT * FROM table) AS t1"
+#
+# To add this extension to an existing dataset:
+#
+#   ds = ds.extension(:implicit_subquery)
+#
+# To set this as the default behavior for all datasets on a single database:
+#
+#   DB.extension(:implicit_subquery)
+#
+# Related module: Sequel::Dataset::ImplicitSubquery
+
+#
+module Sequel
+  class Dataset
+    module ImplicitSubquery
+      exceptions = [:add_graph_aliases, :filter, :from, :from_self, :naked, :or, :order_more,
+                    :qualify, :reverse, :reverse_order, :select_all, :select_more, :server,
+                    :set_graph_aliases, :unfiltered, :ungraphed, :ungrouped, :unlimited, :unordered,
+                    :with_sql]
+      additions = [:join_table]
+      (Dataset::QUERY_METHODS - Dataset::JOIN_METHODS - exceptions + additions).each do |meth|
+        define_method(meth) do |*a, &b|
+          if opts[:sql]
+            from_self.public_send(meth, *a, &b)
+          else
+            super(*a, &b)
+          end
+        end
+      end
+    end
+
+    register_extension(:implicit_subquery, ImplicitSubquery)
+  end
+end