serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3/resultset.rb

@@ -0,0 +1,96 @@
+require "sqlite3/constants"
+require "sqlite3/errors"
+
+module SQLite3
+  # The ResultSet object encapsulates the enumerability of a query's output.
+  # It is a simple cursor over the data that the query returns. It will
+  # very rarely (if ever) be instantiated directly. Instead, clients should
+  # obtain a ResultSet instance via Statement#execute.
+  class ResultSet
+    include Enumerable
+
+    # Create a new ResultSet attached to the given database, using the
+    # given sql text.
+    def initialize db, stmt
+      @db = db
+      @stmt = stmt
+    end
+
+    # Reset the cursor, so that a result set which has reached end-of-file
+    # can be rewound and reiterated.
+    def reset(*bind_params)
+      @stmt.reset!
+      @stmt.bind_params(*bind_params)
+    end
+
+    # Query whether the cursor has reached the end of the result set or not.
+    def eof?
+      @stmt.done?
+    end
+
+    # Obtain the next row from the cursor. If there are no more rows to be
+    # had, this will return +nil+.
+    #
+    # The returned value will be an array, unless Database#results_as_hash has
+    # been set to +true+, in which case the returned value will be a hash.
+    #
+    # For arrays, the column names are accessible via the +fields+ property,
+    # and the column types are accessible via the +types+ property.
+    #
+    # For hashes, the column names are the keys of the hash, and the column
+    # types are accessible via the +types+ property.
+    def next
+      @stmt.step
+    end
+
+    # Required by the Enumerable mixin. Provides an internal iterator over the
+    # rows of the result set.
+    def each
+      while (node = self.next)
+        yield node
+      end
+    end
+
+    # Provides an internal iterator over the rows of the result set where
+    # each row is yielded as a hash.
+    def each_hash
+      while (node = next_hash)
+        yield node
+      end
+    end
+
+    # Closes the statement that spawned this result set.
+    # <em>Use with caution!</em> Closing a result set will automatically
+    # close any other result sets that were spawned from the same statement.
+    def close
+      @stmt.close
+    end
+
+    # Queries whether the underlying statement has been closed or not.
+    def closed?
+      @stmt.closed?
+    end
+
+    # Returns the types of the columns returned by this result set.
+    def types
+      @stmt.types
+    end
+
+    # Returns the names of the columns returned by this result set.
+    def columns
+      @stmt.columns
+    end
+
+    # Return the next row as a hash
+    def next_hash
+      row = @stmt.step
+      return nil if @stmt.done?
+
+      @stmt.columns.zip(row).to_h
+    end
+  end
+
+  class HashResultSet < ResultSet # :nodoc:
+    alias_method :next, :next_hash
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3/statement.rb

@@ -0,0 +1,190 @@
+require "sqlite3/errors"
+require "sqlite3/resultset"
+
+class String
+  def to_blob
+    SQLite3::Blob.new(self)
+  end
+end
+
+module SQLite3
+  # A statement represents a prepared-but-unexecuted SQL query. It will rarely
+  # (if ever) be instantiated directly by a client, and is most often obtained
+  # via the Database#prepare method.
+  class Statement
+    include Enumerable
+
+    # This is any text that followed the first valid SQL statement in the text
+    # with which the statement was initialized. If there was no trailing text,
+    # this will be the empty string.
+    attr_reader :remainder
+
+    # call-seq: SQLite3::Statement.new(db, sql)
+    #
+    # Create a new statement attached to the given Database instance, and which
+    # encapsulates the given SQL text. If the text contains more than one
+    # statement (i.e., separated by semicolons), then the #remainder property
+    # will be set to the trailing text.
+    def initialize(db, sql)
+      raise ArgumentError, "prepare called on a closed database" if db.closed?
+
+      sql = sql.encode(Encoding::UTF_8) if sql && sql.encoding != Encoding::UTF_8
+
+      @connection = db
+      @columns = nil
+      @types = nil
+      @remainder = prepare db, sql
+    end
+
+    # Binds the given variables to the corresponding placeholders in the SQL
+    # text.
+    #
+    # See Database#execute for a description of the valid placeholder
+    # syntaxes.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table where a=? and b=?" )
+    #   stmt.bind_params( 15, "hello" )
+    #
+    # See also #execute, #bind_param, Statement#bind_param, and
+    # Statement#bind_params.
+    def bind_params(*bind_vars)
+      index = 1
+      bind_vars.flatten.each do |var|
+        if Hash === var
+          var.each { |key, val| bind_param key, val }
+        else
+          bind_param index, var
+          index += 1
+        end
+      end
+    end
+
+    # Execute the statement. This creates a new ResultSet object for the
+    # statement's virtual machine. If a block was given, the new ResultSet will
+    # be yielded to it; otherwise, the ResultSet will be returned.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute do |result|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute!.
+    def execute(*bind_vars)
+      reset! if active? || done?
+
+      bind_params(*bind_vars) unless bind_vars.empty?
+      results = @connection.build_result_set self
+
+      step if column_count == 0
+
+      yield results if block_given?
+      results
+    end
+
+    # Execute the statement. If no block was given, this returns an array of
+    # rows returned by executing the statement. Otherwise, each row will be
+    # yielded to the block.
+    #
+    # Any parameters will be bound to the statement using #bind_params.
+    #
+    # Example:
+    #
+    #   stmt = db.prepare( "select * from table" )
+    #   stmt.execute! do |row|
+    #     ...
+    #   end
+    #
+    # See also #bind_params, #execute.
+    def execute!(*bind_vars, &block)
+      execute(*bind_vars)
+      block ? each(&block) : to_a
+    end
+
+    # Returns true if the statement is currently active, meaning it has an
+    # open result set.
+    def active?
+      !done?
+    end
+
+    # Return an array of the column names for this statement. Note that this
+    # may execute the statement in order to obtain the metadata; this makes it
+    # a (potentially) expensive operation.
+    def columns
+      get_metadata unless @columns
+      @columns
+    end
+
+    def each
+      loop do
+        val = step
+        break self if done?
+        yield val
+      end
+    end
+
+    # Return an array of the data types for each column in this statement. Note
+    # that this may execute the statement in order to obtain the metadata; this
+    # makes it a (potentially) expensive operation.
+    def types
+      must_be_open!
+      get_metadata unless @types
+      @types
+    end
+
+    # Performs a sanity check to ensure that the statement is not
+    # closed. If it is, an exception is raised.
+    def must_be_open! # :nodoc:
+      if closed?
+        raise SQLite3::Exception, "cannot use a closed statement"
+      end
+    end
+
+    # Returns a Hash containing information about the statement.
+    # The contents of the hash are implementation specific and may change in
+    # the future without notice. The hash includes information about internal
+    # statistics about the statement such as:
+    #   - +fullscan_steps+: the number of times that SQLite has stepped forward
+    # in a table as part of a full table scan
+    #   - +sorts+: the number of sort operations that have occurred
+    #   - +autoindexes+: the number of rows inserted into transient indices
+    # that were created automatically in order to help joins run faster
+    #   - +vm_steps+: the number of virtual machine operations executed by the
+    # prepared statement
+    #   - +reprepares+: the number of times that the prepare statement has been
+    # automatically regenerated due to schema changes or changes to bound
+    # parameters that might affect the query plan
+    #   - +runs+: the number of times that the prepared statement has been run
+    #   - +filter_misses+: the number of times that the Bloom filter returned
+    # a find, and thus the join step had to be processed as normal
+    #   - +filter_hits+: the number of times that a join step was bypassed
+    # because a Bloom filter returned not-found
+    def stat key = nil
+      if key
+        stat_for(key)
+      else
+        stats_as_hash
+      end
+    end
+
+    private
+
+    # A convenience method for obtaining the metadata about the query. Note
+    # that this will actually execute the SQL, which means it can be a
+    # (potentially) expensive operation.
+    def get_metadata
+      @columns = Array.new(column_count) do |column|
+        column_name column
+      end
+      @types = Array.new(column_count) do |column|
+        val = column_decltype(column)
+        val&.downcase
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3/value.rb

@@ -0,0 +1,54 @@
+require "sqlite3/constants"
+
+module SQLite3
+  class Value
+    attr_reader :handle
+
+    def initialize(db, handle)
+      @driver = db.driver
+      @handle = handle
+    end
+
+    def null?
+      type == :null
+    end
+
+    def to_blob
+      @driver.value_blob(@handle)
+    end
+
+    def length(utf16 = false)
+      if utf16
+        @driver.value_bytes16(@handle)
+      else
+        @driver.value_bytes(@handle)
+      end
+    end
+
+    def to_f
+      @driver.value_double(@handle)
+    end
+
+    def to_i
+      @driver.value_int(@handle)
+    end
+
+    def to_int64
+      @driver.value_int64(@handle)
+    end
+
+    def to_s(utf16 = false)
+      @driver.value_text(@handle, utf16)
+    end
+
+    def type
+      case @driver.value_type(@handle)
+      when Constants::ColumnType::INTEGER then :int
+      when Constants::ColumnType::FLOAT then :float
+      when Constants::ColumnType::TEXT then :text
+      when Constants::ColumnType::BLOB then :blob
+      when Constants::ColumnType::NULL then :null
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3/version.rb

@@ -0,0 +1,4 @@
+module SQLite3
+  # (String) the version of the sqlite3 gem, e.g. "2.1.1"
+  VERSION = "2.9.1"
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3/version_info.rb

@@ -0,0 +1,17 @@
+module SQLite3
+  # a hash of descriptive metadata about the current version of the sqlite3 gem
+  VERSION_INFO = {
+    ruby: RUBY_DESCRIPTION,
+    gem: {
+      version: SQLite3::VERSION
+    },
+    sqlite: {
+      compiled: SQLite3::SQLITE_VERSION,
+      loaded: SQLite3::SQLITE_LOADED_VERSION,
+      packaged: SQLite3::SQLITE_PACKAGED_LIBRARIES,
+      precompiled: SQLite3::SQLITE_PRECOMPILED_LIBRARIES,
+      sqlcipher: SQLite3.sqlcipher?,
+      threadsafe: SQLite3.threadsafe?
+    }
+  }
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sqlite3-2.9.1-x64-mingw-ucrt/lib/sqlite3.rb

@@ -0,0 +1,19 @@
+# support multiple ruby version (fat binaries under windows)
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require "sqlite3/#{$1}/sqlite3_native"
+rescue LoadError
+  require "sqlite3/sqlite3_native"
+end
+
+require "sqlite3/database"
+require "sqlite3/version"
+
+module SQLite3
+  # Was sqlite3 compiled with thread safety on?
+  def self.threadsafe?
+    threadsafe > 0
+  end
+end
+
+require "sqlite3/version_info"

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "rake"
+gem "test-unit"
+gem "test-unit-ruby-core"
+
+# rbs requires ruby 3.0+
+gem "rbs", require: false if !RUBY_VERSION.start_with?('2.')

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/README.md

@@ -0,0 +1,63 @@
+# Webrick
+
+WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a proxy server, and a virtual-host server.
+
+WEBrick features complete logging of both server operations and HTTP access.
+
+WEBrick supports both basic and digest authentication in addition to algorithms not in RFC 2617.
+
+A WEBrick server can be composed of multiple WEBrick servers or servlets to provide differing behavior on a per-host or per-path basis. WEBrick includes servlets for handling CGI scripts, ERB pages, Ruby blocks and directory listings.
+
+WEBrick also includes tools for daemonizing a process and starting a process at a higher privilege level and dropping permissions.
+
+WEBrick is suitable for use in testing and for development.  However, while the developers of WEBrick will attempt to fix security issues, they do not encourage the use of WEBrick to serve production web applications that may be subject to hostile input.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webrick'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webrick
+
+## Usage
+
+To create a new WEBrick::HTTPServer that will listen to connections on port 8000 and serve documents from the current user's public_html folder:
+
+```ruby
+require 'webrick'
+
+root = File.expand_path '~/public_html'
+server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
+```
+
+To run the server you will need to provide a suitable shutdown hook as
+starting the server blocks the current thread:
+
+```ruby
+trap 'INT' do server.shutdown end
+
+server.start
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/webrick.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test/lib"
+  t.ruby_opts << "-rhelper"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/webrick-1.9.2/lib/webrick/accesslog.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+#--
+# accesslog.rb -- Access log handling utilities
+#
+# Author: IPR -- Internet Programming with Ruby -- writers
+# Copyright (c) 2002 keita yamaguchi
+# Copyright (c) 2002 Internet Programming with Ruby writers
+#
+# $IPR: accesslog.rb,v 1.1 2002/10/01 17:16:32 gotoyuzo Exp $
+
+module WEBrick
+
+  ##
+  # AccessLog provides logging to various files in various formats.
+  #
+  # Multiple logs may be written to at the same time:
+  #
+  #   access_log = [
+  #     [$stderr, WEBrick::AccessLog::COMMON_LOG_FORMAT],
+  #     [$stderr, WEBrick::AccessLog::REFERER_LOG_FORMAT],
+  #   ]
+  #
+  #   server = WEBrick::HTTPServer.new :AccessLog => access_log
+  #
+  # Custom log formats may be defined.  WEBrick::AccessLog provides a subset
+  # of the formatting from Apache's mod_log_config
+  # http://httpd.apache.org/docs/mod/mod_log_config.html#formats.  See
+  # AccessLog::setup_params for a list of supported options
+
+  module AccessLog
+
+    ##
+    # Raised if a parameter such as %e, %i, %o or %n is used without fetching
+    # a specific field.
+
+    class AccessLogError < StandardError; end
+
+    ##
+    # The Common Log Format's time format
+
+    CLF_TIME_FORMAT     = "[%d/%b/%Y:%H:%M:%S %Z]"
+
+    ##
+    # Common Log Format
+
+    COMMON_LOG_FORMAT   = "%h %l %u %t \"%r\" %s %b"
+
+    ##
+    # Short alias for Common Log Format
+
+    CLF                 = COMMON_LOG_FORMAT
+
+    ##
+    # Referer Log Format
+
+    REFERER_LOG_FORMAT  = "%{Referer}i -> %U"
+
+    ##
+    # User-Agent Log Format
+
+    AGENT_LOG_FORMAT    = "%{User-Agent}i"
+
+    ##
+    # Combined Log Format
+
+    COMBINED_LOG_FORMAT = "#{CLF} \"%{Referer}i\" \"%{User-agent}i\""
+
+    module_function
+
+    # This format specification is a subset of mod_log_config of Apache:
+    #
+    # %a:: Remote IP address
+    # %b:: Total response size
+    # %e{variable}:: Given variable in ENV
+    # %f:: Response filename
+    # %h:: Remote host name
+    # %{header}i:: Given request header
+    # %l:: Remote logname, always "-"
+    # %m:: Request method
+    # %{attr}n:: Given request attribute from <tt>req.attributes</tt>
+    # %{header}o:: Given response header
+    # %p:: Server's request port
+    # %{format}p:: The canonical port of the server serving the request or the
+    #              actual port or the client's actual port.  Valid formats are
+    #              canonical, local or remote.
+    # %q:: Request query string
+    # %r:: First line of the request
+    # %s:: Request status
+    # %t:: Time the request was received
+    # %T:: Time taken to process the request
+    # %u:: Remote user from auth
+    # %U:: Unparsed URI
+    # %%:: Literal %
+
+    def setup_params(config, req, res)
+      params = Hash.new("")
+      params["a"] = req.peeraddr[3]
+      params["b"] = res.sent_size
+      params["e"] = ENV
+      params["f"] = res.filename || ""
+      params["h"] = req.peeraddr[2]
+      params["i"] = req
+      params["l"] = "-"
+      params["m"] = req.request_method
+      params["n"] = req.attributes
+      params["o"] = res
+      params["p"] = req.port
+      params["q"] = req.query_string
+      params["r"] = req.request_line.sub(/\x0d?\x0a\z/o, '')
+      params["s"] = res.status       # won't support "%>s"
+      params["t"] = req.request_time
+      params["T"] = Time.now - req.request_time
+      params["u"] = req.user || "-"
+      params["U"] = req.unparsed_uri
+      params["v"] = config[:ServerName]
+      params
+    end
+
+    ##
+    # Formats +params+ according to +format_string+ which is described in
+    # setup_params.
+
+    def format(format_string, params)
+      format_string.gsub(/\%(?:\{(.*?)\})?>?([a-zA-Z%])/){
+         param, spec = $1, $2
+         case spec[0]
+         when ?e, ?i, ?n, ?o
+           raise AccessLogError,
+             "parameter is required for \"#{spec}\"" unless param
+           (param = params[spec][param]) ? escape(param) : "-"
+         when ?t
+           params[spec].strftime(param || CLF_TIME_FORMAT)
+         when ?p
+           case param
+           when 'remote'
+             escape(params["i"].peeraddr[1].to_s)
+           else
+             escape(params["p"].to_s)
+           end
+         when ?%
+           "%"
+         else
+           escape(params[spec].to_s)
+         end
+      }
+    end
+
+    ##
+    # Escapes control characters in +data+
+
+    def escape(data)
+      data = data.gsub(/[[:cntrl:]\\]+/) {$&.dump[1...-1]}
+      data.untaint if RUBY_VERSION < '2.7'
+      data
+    end
+  end
+end