Results for: "strip"

HTTPGenericRequest is the parent of the Net::HTTPRequest class. Do not use this directly; use a subclass of Net::HTTPRequest.

Mixes in the Net::HTTPHeader module to provide easier access to HTTP headers.

Gem::StreamUI implements a simple stream based user interface.

Used to construct C classes (CUnion, CStruct, etc)

Fiddle::Importer#struct and Fiddle::Importer#union wrap this functionality in an easy-to-use manner.

Helper methods for both Gem::Installer and Gem::Uninstaller

Numeric is the class from which all higher-level numeric classes should inherit.

Numeric allows instantiation of heap-allocated objects. Other core numeric classes such as Integer are implemented as immediates, which means that each Integer is a single immutable object which is always passed by value.

a = 1
1.object_id == a.object_id   #=> true

There can only ever be one instance of the integer 1, for example. Ruby ensures this by preventing instantiation. If duplication is attempted, the same instance is returned.

Integer.new(1)                   #=> NoMethodError: undefined method `new' for Integer:Class
1.dup                            #=> 1
1.object_id == 1.dup.object_id   #=> true

For this reason, Numeric should be used when defining other numeric classes.

Classes which inherit from Numeric must implement coerce, which returns a two-member Array containing an object that has been coerced into an instance of the new class and self (see coerce).

Inheriting classes should also implement arithmetic operator methods (+, -, * and /) and the <=> operator (see Comparable). These methods may rely on coerce to ensure interoperability with instances of other numeric classes.

class Tally < Numeric
  def initialize(string)
    @string = string
  end

  def to_s
    @string
  end

  def to_i
    @string.size
  end

  def coerce(other)
    [self.class.new('|' * other.to_i), self]
  end

  def <=>(other)
    to_i <=> other.to_i
  end

  def +(other)
    self.class.new('|' * (to_i + other.to_i))
  end

  def -(other)
    self.class.new('|' * (to_i - other.to_i))
  end

  def *(other)
    self.class.new('|' * (to_i * other.to_i))
  end

  def /(other)
    self.class.new('|' * (to_i / other.to_i))
  end
end

tally = Tally.new('||')
puts tally * 2            #=> "||||"
puts tally > 1            #=> true

What’s Here

First, what’s elsewhere. Class Numeric:

• Inherits from class Object.

• Includes module Comparable.

Here, class Numeric provides methods for:

• Querying

• Comparing

• Converting

• Other

Querying

• finite?

  Returns true unless self is infinite or not a number.

• infinite?

  Returns -1, nil or +1, depending on whether self is -Infinity<tt>, finite, or <tt>+Infinity.

• integer?

  Returns whether self is an integer.

• negative?

  Returns whether self is negative.

• nonzero?

  Returns whether self is not zero.

• positive?

  Returns whether self is positive.

• real?

  Returns whether self is a real value.

• zero?

  Returns whether self is zero.

Comparing

• <=>

  Returns:

  • -1 if self is less than the given value.

  • 0 if self is equal to the given value.

  • 1 if self is greater than the given value.

  • nil if self and the given value are not comparable.

• eql?

  Returns whether self and the given value have the same value and type.

Converting

• % (aliased as modulo)

  Returns the remainder of self divided by the given value.

• -@

  Returns the value of self, negated.

• abs (aliased as magnitude)

  Returns the absolute value of self.

• abs2

  Returns the square of self.

• angle (aliased as arg and phase)

  Returns 0 if self is positive, Math::PI otherwise.

• ceil

  Returns the smallest number greater than or equal to self, to a given precision.

• coerce

  Returns array [coerced_self, coerced_other] for the given other value.

• conj (aliased as conjugate)

  Returns the complex conjugate of self.

• denominator

  Returns the denominator (always positive) of the Rational representation of self.

• div

  Returns the value of self divided by the given value and converted to an integer.

• divmod

  Returns array [quotient, modulus] resulting from dividing self the given divisor.

• fdiv

  Returns the Float result of dividing self by the given divisor.

• floor

  Returns the largest number less than or equal to self, to a given precision.

• i

  Returns the Complex object Complex(0, self). the given value.

• imaginary (aliased as imag)

  Returns the imaginary part of the self.

• numerator

  Returns the numerator of the Rational representation of self; has the same sign as self.

• polar

  Returns the array [self.abs, self.arg].

• quo

  Returns the value of self divided by the given value.

• real

  Returns the real part of self.

• rect (aliased as rectangular)

  Returns the array [self, 0].

• remainder

  Returns self-arg*(self/arg).truncate for the given arg.

• round

  Returns the value of self rounded to the nearest value for the given a precision.

• to_c

  Returns the Complex representation of self.

• to_int

  Returns the Integer representation of self, truncating if necessary.

• truncate

  Returns self truncated (toward zero) to a given precision.

Other

• clone

  Returns self; does not allow freezing.

• dup (aliased as +@)

  Returns self.

• step

  Invokes the given block with the sequence of specified numbers.

Raised to stop the iteration, in particular by Enumerator#next. It is rescued by Kernel#loop.

loop do
  puts "Hello"
  raise StopIteration
  puts "World"
end
puts "Done!"

produces:

Hello
Done!

Raised by exit to initiate the termination of the script.

The most standard error types are subclasses of StandardError. A rescue clause without an explicit Exception class will rescue all StandardErrors (and only those).

def foo
  raise "Oups"
end
foo rescue "Hello"   #=> "Hello"

On the other hand:

require 'does/not/exist' rescue "Hi"

raises the exception:

LoadError: no such file to load -- does/not/exist

No longer used by internal code.

SystemCallError is the base class for all low-level platform-dependent errors.

The errors available on the current platform are subclasses of SystemCallError and are defined in the Errno module.

File.open("does/not/exist")

raises the exception:

Errno::ENOENT: No such file or directory - does/not/exist

IPSocket is the super class of TCPSocket and UDPSocket.

IPAddr provides a set of methods to manipulate an IP address. Both IPv4 and IPv6 are supported.

Example

require 'ipaddr'

ipaddr1 = IPAddr.new "3ffe:505:2::1"

p ipaddr1                   #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>

p ipaddr1.to_s              #=> "3ffe:505:2::1"

ipaddr2 = ipaddr1.mask(48)  #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0000/ffff:ffff:ffff:0000:0000:0000:0000:0000>

p ipaddr2.to_s              #=> "3ffe:505:2::"

ipaddr3 = IPAddr.new "192.168.2.0/24"

p ipaddr3                   #=> #<IPAddr: IPv4:192.168.2.0/255.255.255.0>

This class implements a pretty printing algorithm. It finds line breaks and nice indentations for grouped structure.

By default, the class assumes that primitive elements are strings and each byte in the strings have single column in width. But it can be used for other situations by giving suitable arguments for some methods:

• newline object and space generation block for PrettyPrint.new

• optional width argument for PrettyPrint#text

• PrettyPrint#breakable

There are several candidate uses:

• text formatting using proportional fonts

• multibyte characters which has columns different to number of bytes

• non-string formatting

Bugs

• Box based formatting?

• Other (better) model/algorithm?

Report any bugs at bugs.ruby-lang.org

References

Christian Lindig, Strictly Pretty, March 2000, www.st.cs.uni-sb.de/~lindig/papers/#pretty

Philip Wadler, A prettier printer, March 1998, homepages.inf.ed.ac.uk/wadler/topics/language-design.html#prettier

Author

Tanaka Akira <akr@fsij.org>