Results for: "remove_const"

Returns the list of available encoding names.

Encoding.name_list
#=> ["US-ASCII", "ASCII-8BIT", "UTF-8",
      "ISO-8859-1", "Shift_JIS", "EUC-JP",
      "Windows-31J",
      "BINARY", "CP932", "eucJP"]

Returns the singleton class of obj. This method creates a new singleton class if obj does not have one.

If obj is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If obj is an Integer, a Float or a Symbol, it raises a TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj. Only public and protected singleton methods are returned.

module Other
  def three() end
end

class Single
  def Single.four() end
end

a = Single.new

def a.one()
end

class << a
  include Other
  def two()
  end
end

Single.singleton_methods    #=> [:four]
a.singleton_methods(false)  #=> [:two, :one]
a.singleton_methods         #=> [:two, :one, :three]

Similar to method, searches singleton method only.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
def k.hi
  "Hi, @iv = #{@iv}"
end
m = k.singleton_method(:hi)
m.call   #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) #=> NameError

Methods Exception#as_json and Exception.json_create may be used to serialize and deserialize a Exception object; see Marshal.

Method Exception#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/exception'
x = Exception.new('Foo').as_json # => {"json_class"=>"Exception", "m"=>"Foo", "b"=>nil}

Method JSON.create deserializes such a hash, returning a Exception object:

Exception.json_create(x) # => #<Exception: Foo>

Returns a JSON string representing self:

require 'json/add/exception'
puts Exception.new('Foo').to_json

Output:

{"json_class":"Exception","m":"Foo","b":null}

Returns true if mod is a singleton class or false if it is an ordinary class or module.

class C
end
C.singleton_class?                  #=> false
C.singleton_class.singleton_class?  #=> true

Methods BigDecimal#as_json and BigDecimal.json_create may be used to serialize and deserialize a BigDecimal object; see Marshal.

Method BigDecimal#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/bigdecimal'
x = BigDecimal(2).as_json             # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}
y = BigDecimal(2.0, 4).as_json        # => {"json_class"=>"BigDecimal", "b"=>"36:0.2e1"}
z = BigDecimal(Complex(2, 0)).as_json # => {"json_class"=>"BigDecimal", "b"=>"27:0.2e1"}

Method JSON.create deserializes such a hash, returning a BigDecimal object:

BigDecimal.json_create(x) # => 0.2e1
BigDecimal.json_create(y) # => 0.2e1
BigDecimal.json_create(z) # => 0.2e1

Returns a JSON string representing self:

require 'json/add/bigdecimal'
puts BigDecimal(2).to_json
puts BigDecimal(2.0, 4).to_json
puts BigDecimal(Complex(2, 0)).to_json

Output:

{"json_class":"BigDecimal","b":"27:0.2e1"}
{"json_class":"BigDecimal","b":"36:0.2e1"}
{"json_class":"BigDecimal","b":"27:0.2e1"}

Methods Rational#as_json and Rational.json_create may be used to serialize and deserialize a Rational object; see Marshal.

Method Rational#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/rational'
x = Rational(2, 3).as_json
# => {"json_class"=>"Rational", "n"=>2, "d"=>3}

Method JSON.create deserializes such a hash, returning a Rational object:

Rational.json_create(x)
# => (2/3)

Returns a JSON string representing self:

require 'json/add/rational'
puts Rational(2, 3).to_json

Output:

{"json_class":"Rational","n":2,"d":3}

Returns true if the arguments define a valid commercial date, false otherwise:

Date.valid_commercial?(2001, 5, 6) # => true
Date.valid_commercial?(2001, 5, 8) # => false

See Date.commercial.

See argument start.

Related: Date.jd, Date.commercial.

Returns the fractional part of the day in range (Rational(0, 1)…Rational(1, 1)):

DateTime.new(2001,2,3,12).day_fraction # => (1/2)

Returns a copy of self with the given start value:

d0 = Date.new(2000, 2, 3)
d0.julian? # => false
d1 = d0.new_start(Date::JULIAN)
d1.julian? # => true

See argument start.

Methods Date#as_json and Date.json_create may be used to serialize and deserialize a Date object; see Marshal.

Method Date#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/date'
x = Date.today.as_json
# => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}

Method JSON.create deserializes such a hash, returning a Date object:

Date.json_create(x)
# => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>

Returns a JSON string representing self:

require 'json/add/date'
puts Date.today.to_json

Output:

{"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}

Returns the fractional part of the second in range (Rational(0, 1)…Rational(1, 1)):

DateTime.new(2001, 2, 3, 4, 5, 6.5).sec_fraction # => (1/2)

Methods DateTime#as_json and DateTime.json_create may be used to serialize and deserialize a DateTime object; see Marshal.

Method DateTime#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/datetime'
x = DateTime.now.as_json
# => {"json_class"=>"DateTime", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}

Method JSON.create deserializes such a hash, returning a DateTime object:

DateTime.json_create(x) # BUG? Raises Date::Error "invalid date"

Returns a JSON string representing self:

require 'json/add/datetime'
puts DateTime.now.to_json

Output:

{"json_class":"DateTime","y":2023,"m":11,"d":21,"sg":2299161.0}

Methods Time#as_json and Time.json_create may be used to serialize and deserialize a Time object; see Marshal.

Method Time#as_json serializes self, returning a 2-element hash representing self:

require 'json/add/time'
x = Time.now.as_json
# => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}

Method JSON.create deserializes such a hash, returning a Time object:

Time.json_create(x)
# => 2023-11-25 11:00:56.472846644 -0600

Returns a JSON string representing self:

require 'json/add/time'
puts Time.now.to_json

Output:

{"json_class":"Time","s":1700931678,"n":980650786}

Return the number of seconds the specified time zone differs from UTC.

Numeric time zones that include minutes, such as -10:00 or +1330 will work, as will simpler hour-only time zones like -10 or +13.

Textual time zones listed in ZoneOffset are also supported.

If the time zone does not match any of the above, zone_offset will check if the local time zone (both with and without potential Daylight Saving Time changes being in effect) matches zone. Specifying a value for year will change the year used to find the local time zone.

If zone_offset is unable to determine the offset, nil will be returned.

require 'time'

Time.zone_offset("EST") #=> -18000

You must require ‘time’ to use this method.

Returns the number of nanoseconds in the subseconds part of self in the range (0..999_999_999); lower-order digits are truncated, not rounded:

t = Time.now # => 2022-07-11 15:04:53.3219637 -0500
t.nsec       # => 321963700

Related: Time#subsec (returns exact subseconds).

Calls the given block with each codepoint in the stream; returns self:

f = File.new('t.rus')
a = []
f.each_codepoint {|c| a << c }
a # => [1090, 1077, 1089, 1090]
f.close

Returns an Enumerator if no block is given.

Related: IO#each_byte, IO#each_char.