File Manager

X7ROOT File Manager

Current Path: /opt/alt/ruby33/share/ruby

ðŸ“ ..
ðŸ“„ English.rb(5.54 KB)
ðŸ“„ abbrev.rb(3.47 KB)
ðŸ“„ base64.rb(13.22 KB)
ðŸ“„ benchmark.rb(18.42 KB)
ðŸ“ bigdecimal
ðŸ“„ bigdecimal.rb(130 B)
ðŸ“„ bundled_gems.rb(6.86 KB)
ðŸ“ cgi
ðŸ“„ cgi.rb(9.83 KB)
ðŸ“„ coverage.rb(368 B)
ðŸ“ csv
ðŸ“„ csv.rb(92.46 KB)
ðŸ“„ date.rb(1.17 KB)
ðŸ“„ delegate.rb(11.68 KB)
ðŸ“ did_you_mean
ðŸ“„ did_you_mean.rb(5.36 KB)
ðŸ“ digest
ðŸ“„ digest.rb(3.3 KB)
ðŸ“ drb
ðŸ“„ drb.rb(50 B)
ðŸ“ erb
ðŸ“„ erb.rb(14.53 KB)
ðŸ“ error_highlight
ðŸ“„ error_highlight.rb(84 B)
ðŸ“„ expect.rb(2.19 KB)
ðŸ“ fiddle
ðŸ“„ fiddle.rb(2.88 KB)
ðŸ“„ fileutils.rb(78.69 KB)
ðŸ“„ find.rb(2.52 KB)
ðŸ“ forwardable
ðŸ“„ forwardable.rb(9.03 KB)
ðŸ“„ getoptlong.rb(20.26 KB)
ðŸ“ io
ðŸ“„ ipaddr.rb(20.93 KB)
ðŸ“ json
ðŸ“„ json.rb(19.62 KB)
ðŸ“„ kconv.rb(5.72 KB)
ðŸ“ logger
ðŸ“„ logger.rb(22.03 KB)
ðŸ“„ mkmf.rb(88.69 KB)
ðŸ“„ monitor.rb(6.75 KB)
ðŸ“„ mutex_m.rb(2.36 KB)
ðŸ“ net
ðŸ“ objspace
ðŸ“„ objspace.rb(4.14 KB)
ðŸ“„ observer.rb(6.38 KB)
ðŸ“„ open-uri.rb(25.84 KB)
ðŸ“ open3
ðŸ“„ open3.rb(47.51 KB)
ðŸ“ openssl
ðŸ“„ openssl.rb(1.03 KB)
ðŸ“„ optionparser.rb(59 B)
ðŸ“ optparse
ðŸ“„ optparse.rb(61.82 KB)
ðŸ“„ ostruct.rb(14.22 KB)
ðŸ“„ pathname.rb(16.85 KB)
ðŸ“„ pp.rb(17.24 KB)
ðŸ“„ prettyprint.rb(15.93 KB)
ðŸ“ prism
ðŸ“„ prism.rb(3.17 KB)
ðŸ“„ pstore.rb(20.36 KB)
ðŸ“ psych
ðŸ“„ psych.rb(24.44 KB)
ðŸ“ random
ðŸ“„ readline.rb(215 B)
ðŸ“ reline
ðŸ“„ reline.rb(14.7 KB)
ðŸ“„ resolv-replace.rb(1.76 KB)
ðŸ“„ resolv.rb(85.03 KB)
ðŸ“ rinda
ðŸ“ ripper
ðŸ“„ ripper.rb(2.44 KB)
ðŸ“ ruby_vm
ðŸ“„ securerandom.rb(2.06 KB)
ðŸ“ set
ðŸ“„ set.rb(24.94 KB)
ðŸ“„ shellwords.rb(7.11 KB)
ðŸ“„ singleton.rb(3.94 KB)
ðŸ“„ socket.rb(44.04 KB)
ðŸ“ syntax_suggest
ðŸ“„ syntax_suggest.rb(74 B)
ðŸ“ syslog
ðŸ“„ tempfile.rb(14.73 KB)
ðŸ“„ time.rb(23.74 KB)
ðŸ“„ timeout.rb(5.69 KB)
ðŸ“„ tmpdir.rb(4.93 KB)
ðŸ“„ tsort.rb(14.29 KB)
ðŸ“„ un.rb(11.17 KB)
ðŸ“ unicode_normalize
ðŸ“ uri
ðŸ“„ uri.rb(3.06 KB)
ðŸ“ vendor_ruby
ðŸ“„ weakref.rb(1.36 KB)
ðŸ“ yaml
ðŸ“„ yaml.rb(2.13 KB)

Editing: base64.rb

# frozen_string_literal: true
#
# \Module \Base64 provides methods for:
#
# - Encoding a binary string (containing non-ASCII characters)
# as a string of printable ASCII characters.
# - Decoding such an encoded string.
#
# \Base64 is commonly used in contexts where binary data
# is not allowed or supported:
#
# - Images in HTML or CSS files, or in URLs.
# - Email attachments.
#
# A \Base64-encoded string is about one-third larger that its source.
# See the {Wikipedia article}[https://en.wikipedia.org/wiki/Base64]
# for more information.
#
# This module provides three pairs of encode/decode methods.
# Your choices among these methods should depend on:
#
# - Which character set is to be used for encoding and decoding.
# - Whether "padding" is to be used.
# - Whether encoded strings are to contain newlines.
#
# Note: Examples on this page assume that the including program has executed:
#
# require 'base64'
#
# == Encoding Character Sets
#
# A \Base64-encoded string consists only of characters from a 64-character set:
#
# - <tt>('A'..'Z')</tt>.
# - <tt>('a'..'z')</tt>.
# - <tt>('0'..'9')</tt>.
# - <tt>=</tt>, the 'padding' character.
# - Either:
# - <tt>%w[+ /]</tt>:
# {RFC-2045-compliant}[https://datatracker.ietf.org/doc/html/rfc2045];
# _not_ safe for URLs.
# - <tt>%w[- _]</tt>:
# {RFC-4648-compliant}[https://datatracker.ietf.org/doc/html/rfc4648];
# safe for URLs.
#
# If you are working with \Base64-encoded strings that will come from
# or be put into URLs, you should choose this encoder-decoder pair
# of RFC-4648-compliant methods:
#
# - Base64.urlsafe_encode64 and Base64.urlsafe_decode64.
#
# Otherwise, you may choose any of the pairs in this module,
# including the pair above, or the RFC-2045-compliant pairs:
#
# - Base64.encode64 and Base64.decode64.
# - Base64.strict_encode64 and Base64.strict_decode64.
#
# == Padding
#
# \Base64-encoding changes a triplet of input bytes
# into a quartet of output characters.
#
# Padding in Encode Methods
#
# Padding -- extending an encoded string with zero, one, or two trailing
# <tt>=</tt> characters -- is performed by methods Base64.encode64,
# Base64.strict_encode64, and, by default, Base64.urlsafe_encode64:
#
# Base64.encode64('s') # => "cw==\n"
# Base64.strict_encode64('s') # => "cw=="
# Base64.urlsafe_encode64('s') # => "cw=="
# Base64.urlsafe_encode64('s', padding: false) # => "cw"
#
# When padding is performed, the encoded string is always of length 4n,
# where +n+ is a non-negative integer:
#
# - Input bytes of length 3n generate unpadded output characters
# of length 4n:
#
# # n = 1: 3 bytes => 4 characters.
# Base64.strict_encode64('123') # => "MDEy"
# # n = 2: 6 bytes => 8 characters.
# Base64.strict_encode64('123456') # => "MDEyMzQ1"
#
# - Input bytes of length 3n+1 generate padded output characters
# of length 4(n+1), with two padding characters at the end:
#
# # n = 1: 4 bytes => 8 characters.
# Base64.strict_encode64('1234') # => "MDEyMw=="
# # n = 2: 7 bytes => 12 characters.
# Base64.strict_encode64('1234567') # => "MDEyMzQ1Ng=="
#
# - Input bytes of length 3n+2 generate padded output characters
# of length 4(n+1), with one padding character at the end:
#
# # n = 1: 5 bytes => 8 characters.
# Base64.strict_encode64('12345') # => "MDEyMzQ="
# # n = 2: 8 bytes => 12 characters.
# Base64.strict_encode64('12345678') # => "MDEyMzQ1Njc="
#
# When padding is suppressed, for a positive integer n:
#
# - Input bytes of length 3n generate unpadded output characters
# of length 4n:
#
# # n = 1: 3 bytes => 4 characters.
# Base64.urlsafe_encode64('123', padding: false) # => "MDEy"
# # n = 2: 6 bytes => 8 characters.
# Base64.urlsafe_encode64('123456', padding: false) # => "MDEyMzQ1"
#
# - Input bytes of length 3n+1 generate unpadded output characters
# of length 4n+2, with two padding characters at the end:
#
# # n = 1: 4 bytes => 6 characters.
# Base64.urlsafe_encode64('1234', padding: false) # => "MDEyMw"
# # n = 2: 7 bytes => 10 characters.
# Base64.urlsafe_encode64('1234567', padding: false) # => "MDEyMzQ1Ng"
#
# - Input bytes of length 3n+2 generate unpadded output characters
# of length 4n+3, with one padding character at the end:
#
# # n = 1: 5 bytes => 7 characters.
# Base64.urlsafe_encode64('12345', padding: false) # => "MDEyMzQ"
# # m = 2: 8 bytes => 11 characters.
# Base64.urlsafe_encode64('12345678', padding: false) # => "MDEyMzQ1Njc"
#
# Padding in Decode Methods
#
# All of the \Base64 decode methods support (but do not require) padding.
#
# \Method Base64.decode64 does not check the size of the padding:
#
# Base64.decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
#
# \Method Base64.strict_decode64 strictly enforces padding size:
#
# Base64.strict_decode64("MDEyMzQ1Njc") # Raises ArgumentError
# Base64.strict_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
#
# \Method Base64.urlsafe_decode64 allows padding in +str+,
# which if present, must be correct:
# see {Padding}[Base64.html#module-Base64-label-Padding], above:
#
# Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
# Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
#
# == Newlines
#
# An encoded string returned by Base64.encode64 or Base64.urlsafe_encode64
# has an embedded newline character
# after each 60-character sequence, and, if non-empty, at the end:
#
# # No newline if empty.
# encoded = Base64.encode64("\x00" * 0)
# encoded.index("\n") # => nil
#
# # Newline at end of short output.
# encoded = Base64.encode64("\x00" * 1)
# encoded.size # => 4
# encoded.index("\n") # => 4
#
# # Newline at end of longer output.
# encoded = Base64.encode64("\x00" * 45)
# encoded.size # => 60
# encoded.index("\n") # => 60
#
# # Newlines embedded and at end of still longer output.
# encoded = Base64.encode64("\x00" * 46)
# encoded.size # => 65
# encoded.rindex("\n") # => 65
# encoded.split("\n").map {|s| s.size } # => [60, 4]
#
# The string to be encoded may itself contain newlines,
# which are encoded as \Base64:
#
# # Base64.encode64("\n\n\n") # => "CgoK\n"
# s = "This is line 1\nThis is line 2\n"
# Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
#
module Base64

VERSION = "0.2.0"

module_function

# Returns a string containing the RFC-2045-compliant \Base64-encoding of +bin+.
 #
 # Per RFC 2045, the returned string may contain the URL-unsafe characters
 # <tt>+</tt> or <tt>/</tt>;
 # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
 #
 # Base64.encode64("\xFB\xEF\xBE") # => "++++\n"
 # Base64.encode64("\xFF\xFF\xFF") # => "////\n"
 #
 # The returned string may include padding;
 # see {Padding}[Base64.html#module-Base64-label-Padding] above.
 #
 # Base64.encode64('*') # => "Kg==\n"
 #
 # The returned string ends with a newline character, and if sufficiently long
 # will have one or more embedded newline characters;
 # see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
 #
 # Base64.encode64('*') # => "Kg==\n"
 # Base64.encode64('*' * 46)
 # # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq\nKg==\n"
 #
 # The string to be encoded may itself contain newlines,
 # which will be encoded as ordinary \Base64:
 #
 # Base64.encode64("\n\n\n") # => "CgoK\n"
 # s = "This is line 1\nThis is line 2\n"
 # Base64.encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
 #
 def encode64(bin)
 [bin].pack("m")
 end

# Returns a string containing the decoding of an RFC-2045-compliant
 # \Base64-encoded string +str+:
 #
 # s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK\n"
 # Base64.decode64(s) # => "This is line 1\nThis is line 2\n"
 #
 # Non-\Base64 characters in +str+ are ignored;
 # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
 # these include newline characters and characters <tt>-</tt> and <tt>/</tt>:
 #
 # Base64.decode64("\x00\n-_") # => ""
 #
 # Padding in +str+ (even if incorrect) is ignored:
 #
 # Base64.decode64("MDEyMzQ1Njc") # => "01234567"
 # Base64.decode64("MDEyMzQ1Njc=") # => "01234567"
 # Base64.decode64("MDEyMzQ1Njc==") # => "01234567"
 #
 def decode64(str)
 str.unpack1("m")
 end

# Returns a string containing the RFC-2045-compliant \Base64-encoding of +bin+.
 #
 # Per RFC 2045, the returned string may contain the URL-unsafe characters
 # <tt>+</tt> or <tt>/</tt>;
 # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
 #
 # Base64.strict_encode64("\xFB\xEF\xBE") # => "++++\n"
 # Base64.strict_encode64("\xFF\xFF\xFF") # => "////\n"
 #
 # The returned string may include padding;
 # see {Padding}[Base64.html#module-Base64-label-Padding] above.
 #
 # Base64.strict_encode64('*') # => "Kg==\n"
 #
 # The returned string will have no newline characters, regardless of its length;
 # see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
 #
 # Base64.strict_encode64('*') # => "Kg=="
 # Base64.strict_encode64('*' * 46)
 # # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
 #
 # The string to be encoded may itself contain newlines,
 # which will be encoded as ordinary \Base64:
 #
 # Base64.strict_encode64("\n\n\n") # => "CgoK"
 # s = "This is line 1\nThis is line 2\n"
 # Base64.strict_encode64(s) # => "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
 #
 def strict_encode64(bin)
 [bin].pack("m0")
 end

# Returns a string containing the decoding of an RFC-2045-compliant
 # \Base64-encoded string +str+:
 #
 # s = "VGhpcyBpcyBsaW5lIDEKVGhpcyBpcyBsaW5lIDIK"
 # Base64.strict_decode64(s) # => "This is line 1\nThis is line 2\n"
 #
 # Non-\Base64 characters in +str+ not allowed;
 # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
 # these include newline characters and characters <tt>-</tt> and <tt>/</tt>:
 #
 # Base64.strict_decode64("\n") # Raises ArgumentError
 # Base64.strict_decode64('-') # Raises ArgumentError
 # Base64.strict_decode64('_') # Raises ArgumentError
 #
 # Padding in +str+, if present, must be correct:
 #
 # Base64.strict_decode64("MDEyMzQ1Njc") # Raises ArgumentError
 # Base64.strict_decode64("MDEyMzQ1Njc=") # => "01234567"
 # Base64.strict_decode64("MDEyMzQ1Njc==") # Raises ArgumentError
 #
 def strict_decode64(str)
 str.unpack1("m0")
 end

# Returns the RFC-4648-compliant \Base64-encoding of +bin+.
 #
 # Per RFC 4648, the returned string will not contain the URL-unsafe characters
 # <tt>+</tt> or <tt>/</tt>,
 # but instead may contain the URL-safe characters
 # <tt>-</tt> and <tt>_</tt>;
 # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
 #
 # Base64.urlsafe_encode64("\xFB\xEF\xBE") # => "----"
 # Base64.urlsafe_encode64("\xFF\xFF\xFF") # => "____"
 #
 # By default, the returned string may have padding;
 # see {Padding}[Base64.html#module-Base64-label-Padding], above:
 #
 # Base64.urlsafe_encode64('*') # => "Kg=="
 #
 # Optionally, you can suppress padding:
 #
 # Base64.urlsafe_encode64('*', padding: false) # => "Kg"
 #
 # The returned string will have no newline characters, regardless of its length;
 # see {Newlines}[Base64.html#module-Base64-label-Newlines] above:
 #
 # Base64.urlsafe_encode64('*') # => "Kg=="
 # Base64.urlsafe_encode64('*' * 46)
 # # => "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg=="
 #
 def urlsafe_encode64(bin, padding: true)
 str = strict_encode64(bin)
 str.chomp!("==") or str.chomp!("=") unless padding
 str.tr!("+/", "-_")
 str
 end

# Returns the decoding of an RFC-4648-compliant \Base64-encoded string +str+:
  #
  # +str+ may not contain non-Base64 characters;
  # see {Encoding Character Set}[Base64.html#module-Base64-label-Encoding+Character+Sets] above:
  #
  #   Base64.urlsafe_decode64('+')  # Raises ArgumentError.
  #   Base64.urlsafe_decode64('/')  # Raises ArgumentError.
  #   Base64.urlsafe_decode64("\n") # Raises ArgumentError.
  #
  # Padding in +str+, if present, must be correct:
  # see {Padding}[Base64.html#module-Base64-label-Padding], above:
  #
  #   Base64.urlsafe_decode64("MDEyMzQ1Njc") # => "01234567"
  #   Base64.urlsafe_decode64("MDEyMzQ1Njc=") # => "01234567"
  #   Base64.urlsafe_decode64("MDEyMzQ1Njc==") # Raises ArgumentError.
  #
  def urlsafe_decode64(str)
    # NOTE: RFC 4648 does say nothing about unpadded input, but says that
    # "the excess pad characters MAY also be ignored", so it is inferred that
    # unpadded input is also acceptable.
    if !str.end_with?("=") && str.length % 4 != 0
      str = str.ljust((str.length + 3) & ~3, "=")
      str.tr!("-_", "+/")
    else
      str = str.tr("-_", "+/")
    end
    strict_decode64(str)
  end
end

X7ROOT File Manager

Editing: base64.rb

Upload File

Create Folder