Results for: "module_function"

OptionParser::InvalidOption

Raises when switch is undefined.

Racc::LocationPointer

A set of rule and position in it’s RHS. Note that the number of pointers is more than rule’s RHS array, because pointer points right edge of the final symbol when reducing.

Gem::BasicSpecification

BasicSpecification is an abstract class which implements some common code used by both Specification and StubSpecification.

Gem::Exception

Base exception class for RubyGems. All exception raised by RubyGems are a subclass of this one.

Gem::FormatException

Used to raise parsing and loading errors

Gem::OperationNotSupportedError

No documentation available

Gem::VerificationError

Raised by Gem::Validator when something is not right in a gem.

Gem::SystemExitException

Raised to indicate that a system exit should occur with the specified exit_code

Gem::Specification

The Specification class contains the information for a gem. Typically defined in a .gemspec file or a Rakefile, and looks like this:

Gem::Specification.new do |s|
  s.name        = 'example'
  s.version     = '0.1.0'
  s.licenses    = ['MIT']
  s.summary     = "This is an example!"
  s.description = "Much longer explanation of the example!"
  s.authors     = ["Ruby Coder"]
  s.email       = 'rubycoder@example.com'
  s.files       = ["lib/example.rb"]
  s.homepage    = 'https://rubygems.org/gems/example'
  s.metadata    = { "source_code_uri" => "https://github.com/example/example" }
end

Starting in RubyGems 2.0, a Specification can hold arbitrary metadata. See metadata for restrictions on the format and size of metadata items you may add to a specification.

Gem::SpecificationPolicy

No documentation available

Gem::StubSpecification

Gem::StubSpecification reads the stub: line from the gemspec. This prevents us having to eval the entire gemspec in order to find out certain information.

Ractor::IsolationError

No documentation available

Syslog::Option

No documentation available

Net::HTTPExceptions

Net::HTTP exception class. You cannot use Net::HTTPExceptions directly; instead, you must use its subclasses.

Gem::InstallUpdateOptions

Mixin methods for install and update options for Gem::Commands

Gem::SecurityOption

Mixin methods for security option for Gem::Commands

Enumerator::Producer

Producer

IO::EWOULDBLOCKWaitReadable

exception to wait for reading by EWOULDBLOCK. see IO.select.

IO::EWOULDBLOCKWaitWritable

exception to wait for writing by EWOULDBLOCK. see IO.select.

Net::HTTPNotModified

No documentation available

Racc::Rule

No documentation available

Complex

A complex number can be represented as a paired real number with imaginary unit; a+bi. Where a is real part, b is imaginary part and i is imaginary unit. Real a equals complex a+0i mathematically.

You can create a Complex object explicitly with:

You can convert certain objects to Complex objects with:

Complex object can be created as literal, and also by using Kernel#Complex, Complex::rect, Complex::polar or to_c method.

2+1i                 #=> (2+1i)
Complex(1)           #=> (1+0i)
Complex(2, 3)        #=> (2+3i)
Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
3.to_c               #=> (3+0i)

You can also create complex object from floating-point numbers or strings.

Complex(0.3)         #=> (0.3+0i)
Complex('0.3-0.5i')  #=> (0.3-0.5i)
Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)

0.3.to_c             #=> (0.3+0i)
'0.3-0.5i'.to_c      #=> (0.3-0.5i)
'2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
'1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)

A complex object is either an exact or an inexact number.

Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
Complex(1, 1) / 2.0  #=> (0.5+0.5i)

File

A File is an abstraction of any file object accessible by the program and is closely associated with class IO. File includes the methods of module FileTest as class methods, allowing you to write (for example) File.exist?("foo").

In the description of File methods, permission bits are a platform-specific set of bits that indicate permissions of a file. On Unix-based systems, permissions are viewed as a set of three octets, for the owner, the group, and the rest of the world. For each of these entities, permissions may be set to read, write, or execute the file:

The permission bits 0644 (in octal) would thus be interpreted as read/write for owner, and read-only for group and other. Higher-order bits may also be used to indicate the type of file (plain, directory, pipe, socket, and so on) and various other special features. If the permissions are for a directory, the meaning of the execute bit changes; when set the directory can be searched.

On non-Posix operating systems, there may be only the ability to make a file read-only or read-write. In this case, the remaining permission bits will be synthesized to resemble typical values. For instance, on Windows NT the default permission bits are 0644, which means read/write for owner, read-only for all others. The only change that can be made is to make the file read-only, which is reported as 0444.

Various constants for the methods in File can be found in File::Constants.

What’s Here

First, what’s elsewhere. Class File:

Here, class File provides methods that are useful for:

Creating

Querying

Paths

Times

Types

Contents

Settings

Other

NoMethodError

Raised when a method is called on a receiver which doesn’t have it defined and also fails to respond with method_missing.

"hello".to_ary

raises the exception:

NoMethodError: undefined method `to_ary' for "hello":String

NoMemoryError

Raised when memory allocation fails.

Previous Next
Search took: 14ms  ·  Total Results: 3178