Results for: "OptionParser"

Sets the session cache size. Returns the previously valid session cache size. Zero is used to represent an unlimited session cache size.

Returns a Hash containing the following keys:

:accept

Number of started SSL/TLS handshakes in server mode

:accept_good

Number of established SSL/TLS sessions in server mode

:accept_renegotiate

Number of start renegotiations in server mode

:cache_full

Number of sessions that were removed due to cache overflow

:cache_hits

Number of successfully reused connections

:cache_misses

Number of sessions proposed by clients that were not found in the cache

:cache_num

Number of sessions in the internal session cache

:cb_hits

Number of sessions retrieved from the external cache in server mode

:connect

Number of started SSL/TLS handshakes in client mode

:connect_good

Number of established SSL/TLS sessions in client mode

:connect_renegotiate

Number of start renegotiations in client mode

:timeouts

Number of sessions proposed by clients that were found in the cache but had expired due to timeouts

Fetch the end character offset of the value.

Fetch the start character column of the value.

Since prism resolves num params for us, we don’t need to support this kind of logic here.

() ^^

(1) ^^^

1r ^^

/foo #{bar}/ ^^^^^^^^^^^^

-> { _1 + _2 } ^^^^^^^^^^^^^^

-> { _1 + _2 } ^^^^^^^^^^^^^^

Foo += bar

becomes

Foo = Foo + bar

Returns the node id for the given backtrace location.

begin
  raise
rescue =>  e
  loc = e.backtrace_locations.first
  RubyVM::AbstractSyntaxTree.node_id_for_backtrace_location(loc)
end # => 0

def foo(bar, *baz); end

^^^^^^^^^

def foo(bar, *baz); end

^^^^^^^^^

Example:

x += 1
     ^

Create parser string nodes from a single prism node. The parser gem “glues” strings together when a line continuation is encountered.

Foo::Bar += baz ^^^^^^^^^^^^^^^

Returns a new lazy enumerator with the concatenated results of running block once for every element in the lazy enumerator.

["foo", "bar"].lazy.flat_map {|i| i.each_char.lazy}.force
#=> ["f", "o", "o", "b", "a", "r"]

A value x returned by block is decomposed if either of the following conditions is true:

• x responds to both each and force, which means that x is a lazy enumerator.

• x is an array or responds to to_ary.

Otherwise, x is contained as-is in the return value.

[{a:1}, {b:2}].lazy.flat_map {|i| i}.force
#=> [{:a=>1}, {:b=>2}]

Like Enumerable#filter_map, but chains operation to be lazy-evaluated.

(1..).lazy.filter_map { |i| i * 2 if i.even? }.first(5)
#=> [4, 8, 12, 16, 20]

Like Enumerable#drop_while, but chains operation to be lazy-evaluated.

Creates a new Socket::Option object for IP_MULTICAST_LOOP.

The size is dependent on the platform.

sockopt = Socket::Option.int(:INET, :IPPROTO_IP, :IP_MULTICAST_LOOP, 1)
p sockopt.int => 1

p Socket::Option.ipv4_multicast_loop(10)
#=> #<Socket::Option: INET IP MULTICAST_LOOP 10>