': undefined local variable or method `var1' for main:Object (NameError) ~~~ You get an error because `load` and `require` arrange for local variables to be stored into a separate, anonymous namespace, effectively discarding them. This is designed to protect your code from being polluted. --- # Official Ruby FAQ Source: https://www.ruby-lang.org/en/documentation/faq/5.md _If you wish to report errors or suggest improvements for this FAQ, please go to our [GitHub repository](https://github.com/ruby/www.ruby-lang.org/) and open an issue or pull request._ ## Iterators ### What is an iterator? An iterator is a method which accepts a block or a `Proc` object. In the source file, the block is placed immediately after the invocation of the method. Iterators are used to produce user-defined control structures---especially loops. Let's look at an example to see how this works. Iterators are often used to repeat the same action on each element of a collection, like this: ~~~ data = [1, 2, 3] data.each do |i| puts i end ~~~ Produces: ~~~ 1 2 3 ~~~ The each method of the array `data` is passed the `do ... end` block, and executes it repeatedly. On each call, the block is passed successive elements of the array. You can define blocks with `{ ... }` in place of `do ... end`. ~~~ data = [1, 2, 3] data.each { |i| puts i } ~~~ Produces: ~~~ 1 2 3 ~~~ This code has the same meaning as the last example. However, in some cases, precedence issues cause `do ... end` and `{ ... }` to act differently. ~~~ foobar a, b do ... end # foobar is the iterator. foobar a, b { ... } # b is the iterator. ~~~ This is because `{ ... }` binds more tightly to the preceding expression than does a `do ... end` block. The first example is equivalent to `foobar(a, b) do ... end`, while the second is `foobar(a, b { ... })`. ### How can I pass a block to an iterator? You simply place the block after the iterator call. You can also pass a `Proc` object by prepending `&` to the variable or constant name that refers to the `Proc`. ### How is a block used in an iterator?

This section or parts of it might be out-dated or in need of confirmation.

There are three ways to execute a block from an iterator method: (1) the `yield` control structure; (2) calling a `Proc` argument (made from a block) with `call`; and (3) using `Proc.new` followed by a call. The `yield` statement calls the block, optionally passing it one or more arguments. ~~~ def my_iterator yield 1, 2 end my_iterator {|a, b| puts a, b } ~~~ Produces: ~~~ 1 2 ~~~ If a method definition has a block argument (the last formal parameter has an ampersand (`&`) prepended), it will receive the attached block, converted to a `Proc` object. This may be called using `prc.call(args)`. ~~~ def my_iterator(&b) b.call(1, 2) end my_iterator {|a, b| puts a, b } ~~~ Produces: ~~~ 1 2 ~~~ `Proc.new` (or the equivalent `proc` or `lambda` calls), when used in an iterator definition, takes the block which is given to the method as its argument and generates a procedure object from it. (`proc` and `lambda` are effectively synonyms.) _[Update needed: `lambda` behaves in a slightly different way and produces a warning `tried to create Proc object without a block`.]_ ~~~ def my_iterator Proc.new.call(3, 4) proc.call(5, 6) lambda.call(7, 8) end my_iterator {|a, b| puts a, b } ~~~ Produces: ~~~ 3 4 5 6 7 8 ~~~ Perhaps surprisingly, `Proc.new` and friends do not in any sense consume the block attached to the method---each call to `Proc.new` generates a new procedure object out of the same block. You can tell if there is a block associated with a method by calling `block_given?`. ### What does `Proc.new` without a block do? `Proc.new` without a block cannot generate a procedure object and an error occurs. In a method definition, however, `Proc.new` without a block implies the existence of a block at the time the method is called, and so no error will occur. ### How can I run iterators in parallel? Here an adoption of a solution by Matz, in [\[ruby-talk:5252\]][ruby-talk:5252], that uses threads: ~~~ require "thread" def combine(*iterators) queues = [] threads = [] iterators.each do |it| queue = SizedQueue.new(1) th = Thread.new(it, queue) do |i, q| send(i) {|x| q << x } end queues << queue threads << th end loop do ary = [] queues.each {|q| ary << q.pop } yield ary iterators.size.times do |i| return if !threads[i].status && queues[i].empty? end end end def it1 yield 1; yield 2; yield 3 end def it2 yield 4; yield 5; yield 6 end combine(:it1, :it2) do |x| # x is [1, 4], then [2, 5], then [3, 6] end ~~~ [ruby-talk:5252]: https://blade.ruby-lang.org/ruby-talk/5252 --- # Official Ruby FAQ Source: https://www.ruby-lang.org/en/documentation/faq/6.md _If you wish to report errors or suggest improvements for this FAQ, please go to our [GitHub repository](https://github.com/ruby/www.ruby-lang.org/) and open an issue or pull request._ ## Syntax ### What is the difference between an immediate value and a reference? {: #immediate}

This section or parts of it might be out-dated or in need of confirmation.

`Fixnum`, `true`, `nil`, and `false` are implemented as immediate values. With immediate values, variables hold the objects themselves, rather than references to them. Singleton methods cannot be defined for such objects. Two `Fixnums` of the same value always represent the same object instance, so (for example) instance variables for the `Fixnum` with the value `1` are shared between all the `1`'s in the system. This makes it impossible to define a singleton method for just one of these. ### What is the difference between `nil` and `false`? First the similarity: `nil` and `false` are the only two objects that evaluate to `false` in a boolean context. (In other words: they are the only “falsy” values, all other objects are “truthy”.) However, `nil` and `false` are instances of different classes (`NilClass` and `FalseClass`), and have different behavior elsewhere. We recommend that predicate methods (those whose name ends with a question mark) return `true` or `false`. Other methods that need to indicate failure should return `nil`. ### Why is an empty string not `false`? Q: An empty string (`""`) returns `true` in a conditional expression! In Perl, it's `false`. A: But Ruby is not Perl ;-). It's very simple: in Ruby, only `nil` and `false` are false in conditional contexts. You can use `empty?`, compare the string to `""`, or compare the string's `size` or `length` to `0` to find out if a string is empty. ### What does `:name` mean? A colon followed by a name generates a Symbol object which corresponds one to one with the identifier. During the duration of a program's execution the same Symbol object will be created for a given name or string. Symbols can also be created with `"name".intern` or `"name".to_sym`. Symbol objects can represent identifiers for methods, variables, and so on. Some methods, like `define_method`, `method_missing`, or `trace_var`, require a symbol. Other methods, e.g. `attr_accessor`, `send`, or `autoload`, also accept a string. Due to the fact that they are created only once, Symbols are often used as hash keys. String hash keys would create a new object for every single use, thereby causing some memory overhead. There is even a special syntax for symbol hash keys: ~~~ person_1 = { :name => "John", :age => 42 } person_2 = { name: "Jane", age: 24 } # alternate syntax ~~~ Symbols can also be used as enumeration values or to assign unique values to constants: ~~~ status = :open # :closed, ... NORTH = :NORTH SOUTH = :SOUTH ~~~ ### How can I access the value of a symbol? To get the value of the variable corresponding to a symbol, you can use `symbol.to_s` or `"#{symbol}"` to get the name of the variable, and then eval that in the scope of the symbol to get the variable's contents: ~~~ a = "This is the content of `a'" b = eval("#{:a}") a.object_id == b.object_id # => true ~~~ You can also use ~~~ b = binding.local_variable_get(:a) ~~~ If your symbol corresponds to the name of a method, you can use `send`: ~~~ class Demo def hello "Hello, world" end end demo = Demo.new demo.send(:hello) ~~~ Or you can use `Object#method` to return a corresponding `Method` object, which you may then call: ~~~ m = demo.method(:hello) # => # m.call # => "Hello, world" ~~~ ### Is `loop` a control structure? Although `loop` looks like a control structure, it is actually a method defined in `Kernel`. The block which follows introduces a new scope for local variables. ### Ruby doesn't have a post-test loop Q: Ruby does not have a `do { ... } while` construct, so how can I implement loops that test the condition at the end? Clemens Hintze says: You can use a combination of Ruby's `begin ... end` and the `while` or `until` statement modifiers to achieve the same effect: ~~~ i = 0 begin puts "i = #{i}" i += 1 end until i > 4 ~~~ Produces: ~~~ i = 0 i = 1 i = 2 i = 3 i = 4 ~~~ ### Why can't I pass a hash literal to a method: `p {}`? The `{}` is parsed as a block, not a `Hash` constructor. You can force the `{}` to be treated as an expression by making the fact that it's a parameter explicit: `p({})`. ### I can't get `def pos=(val)` to work! I have the following code, but I cannot use the method `pos = 1`. ~~~ def pos=(val) @pos = val puts @pos end ~~~ Methods with `=` appended must be called with an explicit receiver (without the receiver, you are just assigning to a local variable). Invoke it as `self.pos = 1`. ### What is the difference between `'\1'` and `'\\1'`? They have the same meaning. In a single quoted string, only `\'` and `\\` are transformed and other combinations remain unchanged. However, in a double quoted string, `"\1"` is the byte `\001` (an octal bit pattern), while `"\\1"` is the two character string containing a backslash and the character `"1"`. ### What is the difference between `..` and `...`? `..` includes the right hand side in the range, `...` does not: ~~~ (5..8).to_a # => [5, 6, 7, 8] (5...8).to_a # => [5, 6, 7] ~~~ ### What is the difference between `or` and `||`? Q: `p(nil || "Hello")` prints `"Hello"`, while `p(nil or "Hello")` gives a parse error. Why? A: `or` has a very low precedence, `p( (nil or "Hello") )` will work. The precedence of `or` is for instance also lower than that of `=`, whereas `||` has a higher precedence: ~~~ foo = nil || "Hello" # parsed as: foo = (nil || "Hello") foo # => "Hello" # but perhaps surprisingly: foo = nil or "Hello" # parsed as: (foo = nil) or "Hello" foo # => nil ~~~ `or` (and similarly `and`) is best used **not** for combining boolean expressions, but for control flow, like in ~~~ do_something or raise "some error!" ~~~ where `do_something` returns `false` or `nil` when an error occurs. ### Does Ruby have function pointers? A `Proc` object generated by `Proc.new`, `proc`, or `lambda` can be referenced from a variable, so that variable could be said to be a function pointer. You can also get references to methods within a particular object instance using `object.method`. ### What is the difference between `load` and `require`? `load` will load and execute a Ruby program (`*.rb`). `require` loads Ruby programs as well, but will also load binary Ruby extension modules (shared libraries or DLLs). In addition, `require` ensures that a feature is never loaded more than once. ### Does Ruby have exception handling? Ruby supports a flexible exception handling scheme: ~~~ begin statements which may raise exceptions rescue [exception class names] statements when an exception occurred rescue [exception class names] statements when an exception occurred ensure statements that will always run end ~~~ If an exception occurs in the `begin` clause, the `rescue` clause with the matching exception name is executed. The `ensure` clause is executed whether an exception occurred or not. `rescue` and `ensure` clauses may be omitted. If no exception class is designated for a `rescue` clause, `StandardError` exception is implied, and exceptions which are in a `is_a?` relation to `StandardError` are captured. This expression returns the value of the `begin` clause. The latest exception is accessed by the global variable `$!` (and so its type can be determined using `$!.type`). --- # Official Ruby FAQ Source: https://www.ruby-lang.org/en/documentation/faq/7.md _If you wish to report errors or suggest improvements for this FAQ, please go to our [GitHub repository](https://github.com/ruby/www.ruby-lang.org/) and open an issue or pull request._ ## Methods ### How does Ruby choose which method to invoke? Ruby binds all messages to methods dynamically. It searches first for singleton methods in the receiver, then for methods defined in the receiver's own class, and finally for methods defined in the receiver's superclasses (including any modules which may have been mixed in). You can see the order of searching by displaying `ClassName.ancestors`, which shows the ancestor classes and modules of `ClassName`. If after searching the alternatives a matching method could not be found, Ruby tries to invoke a method called `method_missing`, repeating the same search procedure to find it. This allows you to handle messages to unknown methods, and is often used to provide dynamic interfaces to classes. ~~~ module Emphasizable def emphasize "**#{self}**" end end class String include Emphasizable end String.ancestors # => [String, Emphasizable, Comparable, Object, Kernel, BasicObject] "Wow!".emphasize # => "**Wow!**" ~~~ When the method `emphasize` is searched for, it is not found in class `String`, so Ruby searches next in the module `Emphasizable`. In order to override a method that already exists in the receiver's class, e.g. `String#capitalize`, you need to insert the module into the ancestor chain in front of that class, by using `prepend`: ~~~ module PrettyCapitalize def capitalize "**#{super}**" end end class String prepend PrettyCapitalize end String.ancestors # => [PrettyCapitalize, String, Comparable, Object, Kernel, BasicObject] "hello".capitalize # => "**Hello**" ~~~ ### Are `+`, `-`, `*`, ... operators? `+`, `-`, and the like are not operators but method calls. They can, therefore, be overloaded by new definitions. ~~~ class MyString < String def -(other) self[0...other.size] # self truncated to other's size end end ~~~ However, the following are built-in control structures, not methods, which cannot be overridden: ~~~ =, .., ..., not, ||, &&, and, or, :: ~~~ To overload or to define the unary `+` and `-` operators, you need to use `+@` and `-@` as the method names. `=` is used to define a method to set an attribute of the object: ~~~ class Test def attribute=(val) @attribute = val end end t = Test.new t.attribute = 1 ~~~ If operators such as `+` and `-` are defined, Ruby automatically handles the self assignment forms (`+=`, `-=`, and so on). ### Where are `++` and `--` ? Ruby does not have the autoincrement and autodecrement operators. You can use `+= 1` and `-= 1` instead. ### What is a singleton method? {: #singleton-method} A singleton method is an instance method associated with one specific object. You create a singleton method by including the object in the definition: ~~~ class Foo; end foo = Foo.new bar = Foo.new def foo.hello puts "Hello" end foo.hello bar.hello ~~~ Produces: ~~~ Hello prog.rb:11:in `

': undefined method `hello' for # (NoMethodError) ~~~ Singleton methods are useful when you want to add a method to an object and creating a new subclass is not appropriate. ### All these objects are fine, but does Ruby have any simple functions? Yes and no. Ruby has methods that look like functions in languages such as C or Perl: ~~~ def hello(name) puts "Hello, #{name}!" end hello("World") ~~~ Produces: ~~~ Hello, World! ~~~ However, they are actually method calls with the receiver omitted. In this case, Ruby assumes the receiver is self. So, `hello` resembles a function but it's actually a method belonging to class `Object` and sent as a message to the hidden receiver self. Ruby is a pure object-oriented language. Of course you can use such methods as if they were functions. ### So where do all these function-like methods come from? Almost all classes in Ruby are derived from class `Object`. The definition of class `Object` mixes in the methods defined in the `Kernel` module. These methods are therefore available within every object in the system. Even if you are writing a simple Ruby program without classes, you are actually working inside class `Object`. ### Can I access an object's instance variables? An object's instance variables (those variables starting with `@`) are not directly accessible outside the object. This promotes good encapsulation. However, Ruby makes it easy for you to define accessors to these instance variables in such a way that users of your class can treat instance variables just like attributes. Just use one or more of `attr_reader`, `attr_writer`, or `attr_accessor`. ~~~ class Person attr_reader :name # read only attr_accessor :wearing_a_hat # read/write def initialize(name) @name = name end end p = Person.new("Dave") p.name # => "Dave" p.wearing_a_hat # => nil p.wearing_a_hat = true p.wearing_a_hat # => true ~~~ You can also define your own accessor functions (perhaps to perform validation, or to handle derived attributes). The read accessor is simply a method that takes no parameters, and the assignment accessor is a method name ending in `=` that takes a single parameter. Although there can be no space between the method name and the `=` in the method definition, you can insert spaces there when you call the method, making it look like any other assignment. You can also utilize self assignments such as `+=` and `-=`, as long as the corresponding `+` or `-` methods are defined. ### What's the difference between `private` and `protected`? The visibility keyword `private` makes a method callable only in a function form, without an explicit receiver, and so it can only have `self` as its receiver. A private method is callable only within the class in which the method was defined or in its subclasses. ~~~ class Test def foo 99 end def test(other) p foo p other.foo end end t1 = Test.new t2 = Test.new t1.test(t2) # Now make `foo' private class Test private :foo end t1.test(t2) ~~~ Produces: ~~~ 99 99 99 prog.rb:8:in `test': private method `foo' called for # (NoMethodError) from prog.rb:23:in `

' ~~~ Protected methods are also callable only from within their own class or its subclasses, but they can be called both in function form and using a receiver. For example: ~~~ def <=>(other) age <=> other.age end ~~~ Will compile if `age` is a protected method, but not if it is private. These features help you control access to your class's internals. ### How can I change the visibility of a method? You change the visibility of methods using `private`, `protected`, and `public`. When used without parameters during a class definition, they affect the visibility of subsequent methods. When used with parameters, they change the visibility of the named methods. ~~~ class Foo def test puts "hello" end private :test end foo = Foo.new foo.test ~~~ Produces: ~~~ prog.rb:9:in `

': private method `test' called for # (NoMethodError) ~~~ You can make a class method private using `private_class_method`. ~~~ class Foo def self.test puts "hello" end private_class_method :test end Foo.test ~~~ Produces: ~~~ prog.rb:8:in `

': private method `test' called for Foo:Class (NoMethodError) ~~~ The default visibility for the methods defined in a class is public. The exception is the instance initializing method, `initialize`. Methods defined at the toplevel are also public by default. ### Can an identifier beginning with a capital letter be a method name? Yes, it can, but we don't do it lightly! If Ruby sees a capitalized name followed by a space, it will probably (depending on the context) assume it's a constant, not a method name. So, if you use capitalized method names, always remember to put parameter lists in parentheses, and always put the parentheses next to the method name with no intervening spaces. (This last suggestion is a good idea anyway!) ### Calling `super` gives an `ArgumentError`. Invoking `super` with no parameters in a method passes all the arguments of that method to a method of the same name in a superclass. If the number of arguments to the original method disagrees with that of the higher-level method, an `ArgumentError` is raised. To get around this, simply call `super` and pass a suitable number of arguments. ### How can I call the method of the same name two levels up? `super` invokes the same named method one level up. If you are overloading a method in a more distant ancestor, use `alias` to give it a new name before masking it with your method definition. You can then call it using that aliased name. ### How can I invoke an original built-in method after redefining it? Within the method definition, you can use `super`. You can also use `alias` to give it an alternative name. Finally, you can call the original method as a singleton method of `Kernel`. ### What is a destructive method? {: #destructive-method} A destructive method is one which alters the state of an object. `String`, `Array`, `Hash`, and others have such methods. Often there are two versions of a method, one with a plain name, the other with the same name, but followed by `!`. The plain version creates a copy of the receiver, makes its change to it, and returns the copy. The “bang” version (with the `!`) modifies the receiver in place. Beware, however, that there are a fair number of destructive methods that do not have an `!`, including assignment methods (`name=`), array assignment (`[]=`), and methods such as `Array.delete`. ### Why can destructive methods be dangerous? Remember that assignment in most cases just copies object references, and that parameter passing is equivalent to assignment. This means you can end up with multiple variables referencing the same object. If one of those variables is used to invoke a destructive method, the object referenced by all of them will be changed. ~~~ def foo(str) str.sub!(/foo/, "baz") end obj = "foo" foo(obj) # => "baz" obj # => "baz" ~~~ In this case the actual argument is altered. ### Can I return multiple values from a method? Yes and no. ~~~ def m1 return 1, 2, 3 end def m2 [1, 2, 3] end m1 # => [1, 2, 3] m2 # => [1, 2, 3] ~~~ So, only one thing is returned, but that thing can be an arbitrarily complex object. In the case of arrays, you can use multiple assignment to get the effect of multiple return values. For example: ~~~ def foo [20, 4, 17] end a, b, c = foo a # => 20 b # => 4 c # => 17 ~~~ --- # Official Ruby FAQ Source: https://www.ruby-lang.org/en/documentation/faq/8.md _If you wish to report errors or suggest improvements for this FAQ, please go to our [GitHub repository](https://github.com/ruby/www.ruby-lang.org/) and open an issue or pull request._ ## Classes and modules ### Can a class definition be repeated? A class can be defined repeatedly. Each definition is added to the last definition. If a method is redefined, the former one is overridden and lost. ### Are there class variables? There are. A variable prefixed with two at signs (`@@`) is a class variable, accessible within both instance and class methods of the class. ~~~ class Entity @@instances = 0 def initialize @@instances += 1 @number = @@instances end def who_am_i "I'm #{@number} of #{@@instances}" end def self.total @@instances end end entities = Array.new(9) { Entity.new } entities[6].who_am_i # => "I'm 7 of 9" Entity.total # => 9 ~~~ However, you probably should use _class instance variables_ instead. ### What is a class instance variable? Here the example of the previous section rewritten using a class instance variable: ~~~ class Entity @instances = 0 class << self attr_accessor :instances # provide class methods for reading/writing end def initialize self.class.instances += 1 @number = self.class.instances end def who_am_i "I'm #{@number} of #{self.class.instances}" end def self.total @instances end end entities = Array.new(9) { Entity.new } entities[6].who_am_i # => "I'm 7 of 9" Entity.instances # => 9 Entity.total # => 9 ~~~ Here, `@instances` is a _class_ instance variable. It does not belong to an instance of class `Entity`, but to the class object `Entity`, which is an instance of class `Class`. Class instance variables are directly accessible only within class methods of the class. ### What is the difference between class variables and class instance variables? The main difference is the behavior concerning inheritance: class variables are shared between a class and all its subclasses, while class instance variables only belong to one specific class. Class variables in some way can be seen as global variables within the context of an inheritance hierarchy, with all the problems that come with global variables. For instance, a class variable might (accidentally) be reassigned by any of its subclasses, affecting all other classes: ~~~ class Woof @@sound = "woof" def self.sound @@sound end end Woof.sound # => "woof" class LoudWoof < Woof @@sound = "WOOF" end LoudWoof.sound # => "WOOF" Woof.sound # => "WOOF" (!) ~~~ Or, an ancestor class might later be reopened and changed, with possibly surprising effects: ~~~ class Foo @@var = "foo" def self.var @@var end end Foo.var # => "foo" (as expected) class Object @@var = "object" end Foo.var # => "object" (!) ~~~ So, unless you exactly know what you are doing and explicitly need this kind of behavior, you better should use class instance variables. ### Does Ruby have class methods? {: #class-method} A [singleton method](../7/#singleton-method) of a class object is called a class method. (Actually, the class method is defined in the metaclass, but that is pretty much transparent). Another way of looking at it is to say that a class method is a method whose receiver is a class. It all comes down to the fact that you can call class methods without having to have instances of that class (objects) as the receiver. Let's create a singleton method of class `Foo`: ~~~ class Foo def self.test "this is foo" end end # It is invoked this way. Foo.test # => "this is foo" ~~~ In this example, `Foo.test` is a class method. Instance methods which are defined in class `Class` can be used as class methods for every(!) class. ### What is a singleton class? A singleton class is an anonymous class that is created by subclassing the class associated with a particular object. Singleton classes are another way of extending the functionality associated with just one object. Take the lowly `Foo`: ~~~ class Foo def hello "hello" end end foo = Foo.new foo.hello # => "hello" ~~~ Now let's say we need to add class-level functionality to just this one instance: ~~~ class << foo attr_accessor :name def hello "hello, I'm #{name}" end end foo.name = "Tom" foo.hello # => "hello, I'm Tom" Foo.new.hello # => "hello" ~~~ We've customized `foo` without changing the characteristics of `Foo`. ### What is a module function?

This section or parts of it might be out-dated or in need of confirmation.

A module function is a private, singleton method defined in a module. In effect, it is similar to a [class method](#class-method), in that it can be called using the `Module.method` notation: ~~~ Math.sqrt(2) # => 1.414213562 ~~~ However, because modules can be mixed in to classes, module functions can also be used without the prefix (that's how all those `Kernel` functions are made available to objects): ~~~ include Math sqrt(2) # => 1.414213562 ~~~ Use `module_function` to make a method a module function. ~~~ module Test def thing # ... end module_function :thing end ~~~ ### What is the difference between a class and a module? Modules are collections of methods and constants. They cannot generate instances. Classes may generate instances (objects), and have per-instance state (instance variables). Modules may be mixed in to classes and other modules. The mixed in module's constants and methods blend into that class's own, augmenting the class's functionality. Classes, however, cannot be mixed in to anything. A class may inherit from another class, but not from a module. A module may not inherit from anything. ### Can you subclass modules? No. However, a module may be included in a class or another module to mimic multiple inheritance (the mixin facility). This does not generate a subclass (which would require inheritance), but does generate an `is_a?` relationship between the class and the module. ### Give me an example of a mixin The module `Comparable` provides a variety of comparison operators (`<`, `<=`, `==`, `>=`, `>`, `between?`). It defines these in terms of calls to the general comparison method, `<=>`. However, it does not itself define `<=>`. Say you want to create a class where comparisons are based on the number of legs an animal has: ~~~ class Animal include Comparable attr_reader :legs def initialize(name, legs) @name, @legs = name, legs end def <=>(other) legs <=> other.legs end def inspect @name end end c = Animal.new("cat", 4) s = Animal.new("snake", 0) p = Animal.new("parrot", 2) c < s # => false s < c # => true p >= s # => true p.between?(s, c) # => true [p, s, c].sort # => [snake, parrot, cat] ~~~ All `Animal` must do is define its own semantics for the operator `<=>`, and mix in the `Comparable` module. `Comparable`'s methods now become indistinguishable from `Animal`'s and your class suddenly sprouts new functionality. And because the same `Comparable` module is used by many classes, your new class will share a consistent and well understood semantics. ### Why are there two ways of defining class methods? You can define a class method in the class definition, and you can define a class method at the top level. ~~~ class Demo def self.class_method end end def Demo.another_class_method end ~~~ There is only one significant difference between the two. In the class definition you can refer to the class's constants directly, as the constants are within scope. At the top level, you have to use the `Class::CONST` notation. ### What is the difference between `include` and `extend`?

This section or parts of it might be out-dated or in need of confirmation.

`include` mixes a module into a class or another module. Methods from that module are called function-style (without a receiver). `extend` is used to include a module in an object (instance). Methods in the module become methods in the object. ### What does `self` mean? `self` is the currently executing receiver, the object to which a method is applied. A function-style method call implies `self` as the receiver. --- # Official Ruby FAQ Source: https://www.ruby-lang.org/en/documentation/faq/9.md _If you wish to report errors or suggest improvements for this FAQ, please go to our [GitHub repository](https://github.com/ruby/www.ruby-lang.org/) and open an issue or pull request._ ## Built-in libraries ### What does `instance_methods(false)` return? The method `instance_methods` returns an array containing the names of instance methods in the receiving class or module. This will include the methods in superclasses and in mixed in modules. `instance_methods(false)` or `instance_methods(nil)` returns the names of just those methods which are defined in the receiver. ### How do random number seeds work? If `rand` is called without a prior call to `srand`, Ruby's pseudo-random number generator uses a random(ish) seed that amongst other things uses an entropy source provided by the OS, if available. Successive runs of a program that does not use `srand` will generate different sequences of random numbers. For testing purposes, you can get a predictable behavior with the same series of numbers each time the program is run by calling `srand` with a constant seed. ### I read a file and changed it, but the file on disk has not changed. ~~~ File.open("example", "r+").readlines.each_with_index do |line, i| line[0,0] = "#{i+1}: " end ~~~ This program does _not_ add line numbers to the file `example`. It does read the contents of the file, and for each line read does prepend the line number, but the data is never written back. The code below _does_ update the file (although somewhat dangerously, as it takes no backup before starting the update): ~~~ File.open("example", "r+") do |f| lines = f.readlines lines.each_with_index {|line, i| line[0,0] = "#{i+1}: " } f.rewind f.puts lines end ~~~ ### How can I process a file and update its contents? Using the command-line option `-i`, or built-in variable `$-i`, you can read a file and replace it. The code in the preceding question, which added line numbers to a file, is probably best written using this technique: ~~~ $ ruby -i -ne 'print "#$.: #$_"' example ~~~ If you want to preserve the original file, use `-i.bak` to create a backup. ### I wrote a file, copied it, but the end of the copy seems to be lost. This code will not work correctly: ~~~ require "fileutils" File.open("file", "w").puts "This is a file." FileUtils.cp("file", "newfile") ~~~ Because I/O is buffered, `file` is being copied before its contents have been written to disk. `newfile` will probably be empty. However, when the program terminates, the buffers are flushed, and file has the expected content. The problem doesn't arise if you make sure that `file` is closed before copying: ~~~ require "fileutils" File.open("file", "w") {|f| f.puts "This is a file." } FileUtils.cp("file", "newfile") ~~~ ### How can I get the line number in the current input file? As you read from a file, Ruby increments a line number counter in the global variable `$.`. This is also available using the `lineno` attribute of the `File` object. The special constant `ARGF` is a file-like object that can be used to read all the input files specified on the command line (or standard input if there are no files). `ARGF` is used implicitly by code such as: ~~~ while gets print $_ end ~~~ In this case, `$.` will be the cumulative number of lines read across all input files. To get the line number in the current file, use ~~~ ARGF.file.lineno ~~~ You can also get the name of the current file using `ARGF.file.path`. ### How can I use `less` to display my program's output? I tried the following, but nothing came out: ~~~ open("|less", "w").puts "abc" ~~~ That's because the program ends immediately, and `less` never gets a chance to see the stuff you've written to it, never mind to display it. Make sure that the IO is properly closed and it will wait until `less` ends. ~~~ open("|less", "w") {|f| f.puts "abc" } ~~~ ### What happens to a `File` object which is no longer referenced? A `File` object which is no longer referenced becomes eligible for garbage collection. The file will be closed automatically when the `File` object is garbage collected. ### I feel uneasy if I don't close a file. There are at least four good ways of ensuring that you do close a file: ~~~ # (1) f = File.open("file") begin f.each {|line| print line } ensure f.close end # (2) File.open("file") do |f| f.each {|line| print line } end # (3) File.foreach("file") {|line| print line } # (4) File.readlines("file").each {|line| print line } ~~~ ### How can I sort files by their modification time? ~~~ Dir.glob("*").sort {|a, b| File.mtime(b) <=> File.mtime(a) } ~~~ Although this works (returning a list in reverse chronological order) it isn't very efficient, as it fetches the files' modification times from the operating system on every comparison. More efficiency can be bought with some extra complexity: ~~~ Dir.glob("*").map {|f| [File.mtime(f), f] }. sort {|a, b| b[0] <=> a[0] }.map(&:last) ~~~ ### How can I count the frequency of words in a file? ~~~ freq = Hash.new(0) File.read("example").scan(/\w+/) {|word| freq[word] += 1 } freq.keys.sort.each {|word| puts "#{word}: #{freq[word]}" } ~~~ Produces: ~~~ and: 1 is: 3 line: 3 one: 1 this: 3 three: 1 two: 1 ~~~ ### How can I sort strings in alphabetical order? If you want your strings to sort 'AAA', 'BBB', ..., 'ZZZ', 'aaa', 'bbb', then the built-in comparison will work just fine. If you want to sort ignoring case distinctions, compare downcased versions of the strings in the sort block: ~~~ array = %w( z bB Bb bb Aa BB aA AA aa a A ) array.sort {|a, b| a.downcase <=> b.downcase } # => ["a", "A", "Aa", "aA", "AA", "aa", "bB", "Bb", "bb", "BB", "z"] ~~~ If you want to sort so that the 'A's and 'a's come together, but 'a' is considered greater than 'A' (so 'Aa' comes after 'AA' but before 'AB'), use: ~~~ array.sort {|a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b } # => ["A", "a", "AA", "Aa", "aA", "aa", "BB", "Bb", "bB", "bb", "z"] ~~~ ### How can I expand tabs to spaces? {: #tab-expansion} If `a` holds the string to be expanded, you could use one of: ~~~ 1 while a.sub!(/(^[^\t]*)\t(\t*)/){$1+" "*(8-$1.size%8+8*$2.size)} # or 1 while a.sub!(/\t(\t*)/){" "*(8-$~.begin(0)%8+8*$1.size)} # or a.gsub!(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")} ~~~ ### How can I escape a backslash in a regular expression? `Regexp.quote('\\')` escapes a backslash. It gets trickier if you are using `sub` and `gsub`. Say you write `gsub(/\\/, '\\\\')`, hoping to replace each backslash with two. The second argument is converted to `'\\'` in syntax analysis. When the substitution occurs, the regular expression engine converts this to `'\'`, so the net effect is to replace each single backslash with another single backslash. You need to write `gsub(/\\/, '\\\\\\')`! However, using the fact that `\&` contains the matched string, you could also write `gsub(/\\/, '\&\&')`. If you use the block form of `gsub`, i.e. `gsub(/\\/) { '\\\\' }`, the string for substitution is analyzed only once (during the syntax pass) and the result is what you intended. ### What is the difference between `sub` and `sub!`? In `sub`, a copy of the receiver is generated, substituted, and returned. In `sub!`, the receiver is altered and returned if any match was found. Otherwise, `nil` is returned. Methods like `sub!`, which alter the attribute of the receiver, are called [destructive methods](../7/#destructive-method). Usually, if there are two similar methods and one is destructive, the destructive one has a suffix `!`. ~~~ def foo(str) str.sub(/foo/, "baz") end obj = "foo" foo(obj) # => "baz" obj # => "foo" def foo(str) str.sub!(/foo/, "baz") end foo(obj) # => "baz" obj # => "baz" ~~~ ### Where does `\Z` match? `\Z` matches just before the last `\n` (newline) if the string ends with a `\n`, otherwise it matches at the end of a string. ### What is the difference between `thread` and `fork`?

This section or parts of it might be out-dated or in need of confirmation.

Ruby threads are implemented within the interpreter, while `fork` invokes the operating system to create a separately executing subprocess. Thread and fork have the following characteristics: * `fork` is slow, `thread` is not. * `fork` does not share the memory space. * `thread` does not cause thrashing. * `thread` works on DOS. * When `thread` gets in a deadlock, the whole process stops. * `fork` can take advantage of pauses waiting for I/O to complete, `thread` does not (at least not without some help). You probably shouldn't mix `fork` and `thread`. ### How can I use `Marshal`? `Marshal` is used to store an object in a file or a string, and later reconstitute it. Objects may be stored using: ~~~ Marshal.dump( obj [, io ] [, lev] ) ~~~ `io` is a writable `IO` object, `lev` designates the level to which objects are dereferred and stored. If `lev` levels of dereferring are done and object references still exist, then `dump` stores just the reference, not the object referenced. This is not good, as these referenced objects cannot be subsequently reconstructed. If `io` is omitted, the marshaled objects are returned in a string. You can load objects back using: ~~~ obj = Marshal.load(io) # or obj = Marshal.load(str) ~~~ where `io` is a readable `IO` object, `str` is the dumped string. ### How can I use `trap`? `trap` associates code blocks with external events (signals). ~~~ trap("PIPE") { raise "SIGPIPE" } ~~~ --- # Installing Ruby Source: https://www.ruby-lang.org/en/documentation/installation.md With package managers or third-party tools, you have plenty of options to install and manage Ruby. {: .summary} You may already have Ruby installed on your computer. You can check inside a [terminal emulator][terminal] by typing:

ruby -v

This should output some information on the installed Ruby version. ## Choose Your Installation Method There are several ways to install Ruby: * On a UNIX-like operating system, using your system's **package manager** is easiest. However, the packaged Ruby version may not be the newest one. * **Installers** can be used to install a specific or multiple Ruby versions. There is also an installer for Windows. * **Managers** help you to switch between multiple Ruby versions on your system. * Finally, you can also **build Ruby from source**. On Windows 10, you can also use the [Windows Subsystem for Linux][wsl] to install one of the supported Linux distributions and use any of the installation methods available on that system. Here are available installation methods: * [Package Management Systems](#package-management-systems) * [Debian, Ubuntu](#apt) * [CentOS, Fedora, RHEL](#yum) * [Snap](#snap) * [Gentoo](#portage) * [Arch Linux](#pacman) * [macOS](#homebrew) * [FreeBSD](#freebsd) * [OpenBSD](#openbsd) * [OpenIndiana](#openindiana) * [Windows Package Manager](#winget) * [Chocolatey package manager for Windows](#chocolatey) * [Other Distributions](#other-systems) * [Installers](#installers) * [ruby-build](#ruby-build) * [ruby-install](#ruby-install) * [RubyInstaller](#rubyinstaller) (Windows) * [Ruby Stack](#rubystack) * [Managers](#managers) * [asdf-vm](#asdf-vm) * [chruby](#chruby) * [mise-en-place](#mise-en-place) * [rbenv](#rbenv) * [rbenv for Windows](#rbenv-for-windows) * [RVM](#rvm) * [uru](#uru) * [Building from source](#building-from-source) ## Package Management Systems {: #package-management-systems} If you cannot compile your own Ruby, and you do not want to use a third-party tool, you can use your system's package manager to install Ruby. Some members of the Ruby community feel that you should avoid package managers to install Ruby and that you should use dedicated tools instead. It is possible that major package managers will install older Ruby versions instead of the latest release. To use the latest Ruby release, check that the package name matches its version number. Or use a dedicated [installer][installers]. ### apt (Debian or Ubuntu) {: #apt} Debian GNU/Linux and Ubuntu use the apt package manager. You can use it like this:

$ sudo apt-get install ruby-full

### yum (CentOS, Fedora, or RHEL) {: #yum} CentOS, Fedora, and RHEL use the yum package manager. You can use it like this:

$ sudo yum install ruby

The installed version is typically the latest version of Ruby available at the release time of the specific distribution version. ### snap (Ubuntu or other Linux distributions) {: #snap} Snap is a package manager developed by Canonical. It is available out-of-the-box on Ubuntu, but snap also works on many other Linux distributions. You can use it like this:

$ sudo snap install ruby --classic

We have several channels per Ruby minor series. For instance, the following commands switch to Ruby 2.3:

$ sudo snap switch ruby --channel=2.3/stable
$ sudo snap refresh

### portage (Gentoo) {: #portage} Gentoo uses the portage package manager.

$ sudo emerge dev-lang/ruby

To install a specific version, set `RUBY_TARGETS` in your `make.conf`. See the [Gentoo Ruby Project website][gentoo-ruby] for details. ### pacman (Arch Linux) {: #pacman} Arch Linux uses a package manager named pacman. To get Ruby, just do this:

$ sudo pacman -S ruby

### Homebrew (macOS) {: #homebrew} Ruby versions 2.0 and above are included by default in macOS releases since at least El Capitan (10.11). [Homebrew][homebrew] is a commonly used package manager on macOS. Installing Ruby using Homebrew is easy:

$ brew install ruby

This should install the latest Ruby version. ### FreeBSD {: #freebsd} FreeBSD offers both pre-packaged and source-based methods to install Ruby. Prebuilt packages can be installed via the pkg tool:

$ pkg install ruby

A source-based method can be used to install Ruby using the [Ports Collection][freebsd-ports-collection]. This is useful if you want to customize the build configuration options. More information about Ruby and its surrounding ecosystem on FreeBSD can be found on the [FreeBSD Ruby Project website][freebsd-ruby]. ### OpenBSD {: #openbsd} OpenBSD as well as its distribution adJ has packages for the three major versions of Ruby. The following command allows you to see the available versions and to install one:

$ doas pkg_add ruby

You can install multiple major versions side by side, because their binaries have different names (e.g. `ruby27`, `ruby26`). The `HEAD` branch of the OpenBSD ports collection might have the most recent version of Ruby for this platform some days after it is released, see [directory lang/ruby in the most recent ports collection][openbsd-current-ruby-ports]. ### Ruby on OpenIndiana {: #openindiana} To install Ruby on [OpenIndiana][openindiana], please use the Image Packaging System (IPS) client. This will install the Ruby binaries and RubyGems directly from the OpenIndiana repositories. It’s easy:

$ pkg install runtime/ruby

However, the third-party tools might be a good way to obtain the latest version of Ruby. ### Windows Package Manager {: #winget} On Windows, you can use the [Windows Package Manager CLI](https://github.com/microsoft/winget-cli) to install Ruby:

> winget install RubyInstallerTeam.Ruby.{MAJOR}.{MINOR}
# Example
> winget install RubyInstallerTeam.Ruby.3.2
# To see all versions available
> winget search RubyInstallerTeam.Ruby
# Note: if you are installing ruby for projects, you may want to install RubyWithDevKit
> winget install RubyInstallerTeam.RubyWithDevKit.3.2

### Chocolatey package manager for Windows {: #chocolatey} Also on Windows, you can use the [Chocolatey Package Manager](https://chocolatey.org/install) to install Ruby:

> choco install ruby

It will reuse existing `msys2`, or install own for complete Ruby development environment ### Other Distributions {: #other-systems} On other systems, you can search the package repository of your Linux distribution's manager for Ruby. Alternatively, you can use a [third-party installer][installers]. ## Installers {: #installers} If the version of Ruby provided by your system or package manager is out of date, a newer one can be installed using a third-party installer. Some installers allow you to install multiple versions on the same system; associated managers can help to switch between the different Rubies. If you are planning to use [RVM](#rvm) as a version manager you don't need a separate installer, it comes with its own. ### ruby-build {: #ruby-build} [ruby-build][ruby-build] is a plugin for [rbenv](#rbenv) that allows you to compile and install different versions of Ruby. ruby-build can also be used as a standalone program without rbenv. It is available for macOS, Linux, and other UNIX-like operating systems. ### ruby-install {: #ruby-install} [ruby-install][ruby-install] allows you to compile and install different versions of Ruby into arbitrary directories. [chruby](#chruby) is a complimentary tool used to switch between Ruby versions. It is available for macOS, Linux, and other UNIX-like operating systems. ### RubyInstaller {: #rubyinstaller} On Windows, [RubyInstaller][rubyinstaller] gives you everything you need to set up a full Ruby development environment. Just download it, run it, and you are done! ### Ruby Stack {: #rubystack} If you are installing Ruby in order to use Ruby on Rails, you can use the following installer: * [Bitnami Ruby Stack][rubystack] provides a complete development environment for Rails. It supports macOS, Linux, Windows, virtual machines, and cloud images. ## Managers {: #managers} Many Rubyists use Ruby managers to manage multiple Rubies. They allow easy or even automatic switching between Ruby versions depending on the project and other advantages but are not officially supported. You can however find support within their respective communities. ### asdf-vm {: #asdf-vm} [asdf-vm][asdf-vm] is an extendable version manager that can manage multiple language runtime versions on a per-project basis. You will need the [asdf-ruby][asdf-ruby] plugin (which in turn uses [ruby-build](#ruby-build)) to install Ruby. ### chruby {: #chruby} [chruby][chruby] allows you to switch between multiple Rubies. It can manage Rubies installed by [ruby-install](#ruby-install) or even built from source. ### mise-en-place {: #mise-en-place} [mise-en-place][mise-en-place] allows you to switch between multiple Rubies without requiring additional tools. It manages installations automatically and includes a [gem backend](https://mise.jdx.dev/dev-tools/backends/gem.html) to manage versions of CLIs written in Ruby. It supports UNIX-like and Windows operating systems. ### rbenv {: #rbenv} [rbenv][rbenv] allows you to manage multiple installations of Ruby. While it can't install Ruby by default, its [ruby-build](#ruby-build) plugin can. Both tools are available for macOS, Linux, or other UNIX-like operating systems. ### rbenv for Windows {: #rbenv-for-windows} [rbenv for Windows][rbenv-for-windows] allows you to install and manage multiple installations of Ruby on Windows. It's written in PowerShell thus providing a native way to use Ruby for Windows users. Besides, the command line interface is compatible with [rbenv][rbenv] on UNIX-like systems. ### RVM ("Ruby Version Manager") {: #rvm} [RVM][rvm] allows you to install and manage multiple installations of Ruby on your system. It can also manage different gemsets. It is available for macOS, Linux, or other UNIX-like operating systems. ### RVM 4 Windows {: #rvm-windows} [RVM 4 Windows][rvm-windows] allows you to install and manage multiple installations of Ruby on Windows. It is a clone of the original RVM and supports the classic command line as well as Powershell by providing the same command line interface as the original RVM. ### uru {: #uru} [Uru][uru] is a lightweight, multi-platform command line tool that helps you to use multiple Rubies on macOS, Linux, or Windows systems. ## Building from Source {: #building-from-source} Of course, you can install Ruby from source. [Download][download] and unpack a tarball, then just do this:

$ ./configure
$ make
$ sudo make install

By default, this will install Ruby into `/usr/local`. To change, pass the `--prefix=DIR` option to the `./configure` script. You can find more information about building from source in the [Building Ruby instructions][building-ruby]. Using the third-party tools or package managers might be a better idea, though, because the installed Ruby won't be managed by any tools. [rvm]: http://rvm.io/ [rvm-windows]: https://github.com/magynhard/rvm-windows#readme [rbenv]: https://github.com/rbenv/rbenv#readme [rbenv-for-windows]: https://github.com/RubyMetric/rbenv-for-windows#readme [ruby-build]: https://github.com/rbenv/ruby-build#readme [ruby-install]: https://github.com/postmodern/ruby-install#readme [chruby]: https://github.com/postmodern/chruby#readme [uru]: https://bitbucket.org/jonforums/uru [rubyinstaller]: https://rubyinstaller.org/ [rubystack]: http://bitnami.com/stack/ruby/installer [openindiana]: http://openindiana.org/ [gentoo-ruby]: http://www.gentoo.org/proj/en/prog_lang/ruby/ [freebsd-ruby]: https://wiki.freebsd.org/Ruby [freebsd-ports-collection]: https://www.freebsd.org/doc/en_US.ISO8859-1/books/handbook/ports-using.html [homebrew]: http://brew.sh/ [terminal]: https://en.wikipedia.org/wiki/List_of_terminal_emulators [download]: /en/downloads/ [installers]: /en/documentation/installation/#installers [building-ruby]: https://docs.ruby-lang.org/en/master/contributing/building_ruby_md.html [wsl]: https://docs.microsoft.com/en-us/windows/wsl/about [asdf-vm]: https://asdf-vm.com/ [asdf-ruby]: https://github.com/asdf-vm/asdf-ruby [mise-en-place]: https://mise.jdx.dev [mise-en-place-ruby]: https://mise.jdx.dev/lang/ruby.html [openbsd-current-ruby-ports]: https://cvsweb.openbsd.org/cgi-bin/cvsweb/ports/lang/ruby/?only_with_tag=HEAD --- # Ruby in Twenty Minutes Source: https://www.ruby-lang.org/en/documentation/quickstart.md ## Introduction This is a small Ruby tutorial that should take no more than 20 minutes to complete. It makes the assumption that you already have Ruby installed. (If you do not have Ruby on your computer [install][installation] it before you get started.) ## Interactive Ruby Ruby comes with a program that will show the results of any Ruby statements you feed it. Playing with Ruby code in interactive sessions like this is a terrific way to learn the language. Open up IRB (which stands for Interactive Ruby). * If you’re using **macOS** open up `Terminal` and type `irb`, then hit enter. * If you’re using **Linux**, open up a shell and type `irb` and hit enter. * If you’re using **Windows**, open `Interactive Ruby` from the Ruby section of your Start Menu.

irb(main):001:0>

Ok, so it’s open. Now what? Type this: `"Hello World"`

irb(main):001:0> "Hello World"
=> "Hello World"

## Ruby Obeyed You! What just happened? Did we just write the world’s shortest “Hello World” program? Not exactly. The second line is just IRB’s way of telling us the result of the last expression it evaluated. If we want to print out “Hello World” we need a bit more:

irb(main):002:0> puts "Hello World"
Hello World
=> nil

`puts` is the basic command to print something out in Ruby. But then what’s the `=> nil` bit? That’s the result of the expression. `puts` always returns nil, which is Ruby’s absolutely-positively-nothing value. ## Your Free Calculator is Here Already, we have enough to use IRB as a basic calculator:

irb(main):003:0> 3+2
=> 5

Three plus two. Easy enough. What about three *times* two? You could type it in, it’s short enough, but you may also be able to go up and change what you just entered. Try hitting the **up-arrow** on your keyboard and see if it brings up the line with `3+2` on it. If it does, you can use the left arrow key to move just after the `+` sign and then use backspace to change it to a `*` sign.

irb(main):004:0> 3*2
=> 6

Next, let’s try three squared:

irb(main):005:0> 3**2
=> 9

In Ruby `**` is the way you say “to the power of”. But what if you want to go the other way and find the square root of something?

irb(main):006:0> Math.sqrt(9)
=> 3.0

Ok, wait, what was that last one? If you guessed, “it was figuring out the square root of nine,” you’re right. But let’s take a closer look at things. First of all, what’s `Math`? ## Modules Group Code by Topic `Math` is a built-in module for mathematics. Modules serve two roles in Ruby. This shows one role: grouping similar methods together under a familiar name. `Math` also contains methods like `sin()` and `tan()`. Next is a dot. What does the dot do? The dot is how you identify the receiver of a message. What’s the message? In this case it’s `sqrt(9)`, which means call the method `sqrt`, shorthand for “square root” with the parameter of `9`. The result of this method call is the value `3.0`. You might notice it’s not just `3`. That’s because most of the time the square root of a number won’t be an integer, so the method always returns a floating-point number. What if we want to remember the result of some of this math? Assign the result to a variable.

irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0

As great as this is for a calculator, we’re getting away from the traditional `Hello World` message that beginning tutorials are supposed to focus on… [so let’s go back to that.](2/) [installation]: /en/documentation/installation/ --- # Ruby in Twenty Minutes Source: https://www.ruby-lang.org/en/documentation/quickstart/2.md What if we want to say “Hello” a lot without getting our fingers all tired? We need to define a method!

irb(main):010:0> def hi
irb(main):011:1> puts "Hello World!"
irb(main):012:1> end
=> :hi

The code `def hi` starts the definition of the method. It tells Ruby that we’re defining a method, that its name is `hi`. The next line is the body of the method, the same line we saw earlier: `puts "Hello World"`. Finally, the last line `end` tells Ruby we’re done defining the method. Ruby’s response `=> :hi` tells us that it knows we’re done defining the method. This response could be `=> nil` for Ruby 2.0 and earlier versions. But, it's not important here, so let's go on. ## The Brief, Repetitive Lives of a Method Now let’s try running that method a few times:

irb(main):013:0> hi
Hello World!
=> nil
irb(main):014:0> hi()
Hello World!
=> nil

Well, that was easy. Calling a method in Ruby is as easy as just mentioning its name to Ruby. If the method doesn’t take parameters that’s all you need. You can add empty parentheses if you’d like, but they’re not needed. What if we want to say hello to one person, and not the whole world? Just redefine `hi` to take a name as a parameter.

irb(main):015:0> def hi(name)
irb(main):016:1> puts "Hello #{name}!"
irb(main):017:1> end
=> :hi
irb(main):018:0> hi("Matz")
Hello Matz!
=> nil

So it works… but let’s take a second to see what’s going on here. ## Holding Spots in a String What’s the `#{name}` bit? That’s Ruby’s way of inserting something into a string. The bit between the braces is turned into a string (if it isn’t one already) and then substituted into the outer string at that point. You can also use this to make sure that someone’s name is properly capitalized:

irb(main):019:0> def hi(name = "World")
irb(main):020:1> puts "Hello #{name.capitalize}!"
irb(main):021:1> end
=> :hi
irb(main):022:0> hi "chris"
Hello Chris!
=> nil
irb(main):023:0> hi
Hello World!
=> nil

A couple of other tricks to spot here. One is that we’re calling the method without parentheses again. If it’s obvious what you’re doing, the parentheses are optional. The other trick is the default parameter `World`. What this is saying is “If the name isn’t supplied, use the default name of `"World"`”. ## Evolving Into a Greeter What if we want a real greeter around, one that remembers your name and welcomes you and treats you always with respect. You might want to use an object for that. Let’s create a “Greeter” class.

irb(main):024:0> class Greeter
irb(main):025:1>   def initialize(name = "World")
irb(main):026:2>     @name = name
irb(main):027:2>   end
irb(main):028:1>   def say_hi
irb(main):029:2>     puts "Hi #{@name}!"
irb(main):030:2>   end
irb(main):031:1>   def say_bye
irb(main):032:2>     puts "Bye #{@name}, come back soon."
irb(main):033:2>   end
irb(main):034:1> end
=> :say_bye

The new keyword here is `class`. This defines a new class called Greeter and a bunch of methods for that class. Also notice `@name`. This is an instance variable, and is available to all the methods of the class. As you can see it’s used by `say_hi` and `say_bye`. So how do we get this Greeter class set in motion? [Create an object.](../3/) --- # Ruby in Twenty Minutes Source: https://www.ruby-lang.org/en/documentation/quickstart/3.md Now let’s create a greeter object and use it:

irb(main):035:0> greeter = Greeter.new("Pat")
=> #<Greeter:0x16cac @name="Pat">
irb(main):036:0> greeter.say_hi
Hi Pat!
=> nil
irb(main):037:0> greeter.say_bye
Bye Pat, come back soon.
=> nil

Once the `greeter` object is created, it remembers that the name is Pat. Hmm, what if we want to get at the name directly?

irb(main):038:0> greeter.@name
SyntaxError: (irb):38: syntax error, unexpected tIVAR, expecting '('

Nope, can’t do it. ## Under the Object’s Skin Instance variables are hidden away inside the object. They’re not terribly hidden, you see them whenever you inspect the object, and there are other ways of accessing them, but Ruby uses the good object-oriented approach of keeping data sort-of hidden away. So what methods do exist for Greeter objects?

irb(main):039:0> Greeter.instance_methods
=> [:say_hi, :say_bye, :instance_of?, :public_send,
    :instance_variable_get, :instance_variable_set,
    :instance_variable_defined?, :remove_instance_variable,
    :private_methods, :kind_of?, :instance_variables, :tap,
    :is_a?, :extend, :define_singleton_method, :to_enum,
    :enum_for, :<=>, :===, :=~, :!~, :eql?, :respond_to?,
    :freeze, :inspect, :display, :send, :object_id, :to_s,
    :method, :public_method, :singleton_method, :nil?, :hash,
    :class, :singleton_class, :clone, :dup, :itself, :taint,
    :tainted?, :untaint, :untrust, :trust, :untrusted?, :methods,
    :protected_methods, :frozen?, :public_methods, :singleton_methods,
    :!, :==, :!=, :__send__, :equal?, :instance_eval, :instance_exec, :__id__]

Whoa. That’s a lot of methods. We only defined two methods. What’s going on here? Well this is **all** of the methods for Greeter objects, a complete list, including ones defined by ancestor classes. If we want to just list methods defined for Greeter we can tell it to not include ancestors by passing it the parameter `false`, meaning we don’t want methods defined by ancestors.

irb(main):040:0> Greeter.instance_methods(false)
=> [:say_hi, :say_bye]

Ah, that’s more like it. So let’s see which methods our greeter object responds to:

irb(main):041:0> greeter.respond_to?("name")
=> false
irb(main):042:0> greeter.respond_to?("say_hi")
=> true
irb(main):043:0> greeter.respond_to?("to_s")
=> true

So, it knows `say_hi`, and `to_s` (meaning convert something to a string, a method that’s defined by default for every object), but it doesn’t know `name`. ## Altering Classes—It’s Never Too Late But what if you want to be able to view or change the name? Ruby provides an easy way of providing access to an object’s variables.

irb(main):044:0> class Greeter
irb(main):045:1>   attr_accessor :name
irb(main):046:1> end
=> [:name, :name=]

In Ruby, you can reopen a class and modify it. The changes will be present in any new objects you create and even available in existing objects of that class. So, let’s create a new object and play with its `@name` property.

irb(main):047:0> greeter = Greeter.new("Andy")
=> #<Greeter:0x3c9b0 @name="Andy">
irb(main):048:0> greeter.respond_to?("name")
=> true
irb(main):049:0> greeter.respond_to?("name=")
=> true
irb(main):050:0> greeter.say_hi
Hi Andy!
=> nil
irb(main):051:0> greeter.name="Betty"
=> "Betty"
irb(main):052:0> greeter
=> #<Greeter:0x3c9b0 @name="Betty">
irb(main):053:0> greeter.name
=> "Betty"
irb(main):054:0> greeter.say_hi
Hi Betty!
=> nil

Using `attr_accessor` defined two new methods for us, `name` to get the value, and `name=` to set it. ## Greeting Anything and Everything, MegaGreeter Neglects None! This greeter isn’t all that interesting though, it can only deal with one person at a time. What if we had some kind of MegaGreeter that could either greet the world, one person, or a whole list of people? Let’s write this one in a file instead of directly in the interactive Ruby interpreter IRB. To quit IRB, type “quit”, “exit” or just hit Control-D.

#!/usr/bin/env ruby

class MegaGreeter
  attr_accessor :names

  # Create the object
  def initialize(names = "World")
    @names = names
  end

  # Say hi to everybody
  def say_hi
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("each")
      # @names is a list of some kind, iterate!
      @names.each do |name|
        puts "Hello #{name}!"
      end
    else
      puts "Hello #{@names}!"
    end
  end

  # Say bye to everybody
  def say_bye
    if @names.nil?
      puts "..."
    elsif @names.respond_to?("join")
      # Join the list elements with commas
      puts "Goodbye #{@names.join(", ")}.  Come back soon!"
    else
      puts "Goodbye #{@names}.  Come back soon!"
    end
  end
end


if __FILE__ == $0
  mg = MegaGreeter.new
  mg.say_hi
  mg.say_bye

  # Change name to be "Zeke"
  mg.names = "Zeke"
  mg.say_hi
  mg.say_bye

  # Change the name to an array of names
  mg.names = ["Albert", "Brenda", "Charles",
              "Dave", "Engelbert"]
  mg.say_hi
  mg.say_bye

  # Change to nil
  mg.names = nil
  mg.say_hi
  mg.say_bye
end

Save this file as “ri20min.rb”, and run it as “ruby ri20min.rb”. The output should be: Hello World! Goodbye World. Come back soon! Hello Zeke! Goodbye Zeke. Come back soon! Hello Albert! Hello Brenda! Hello Charles! Hello Dave! Hello Engelbert! Goodbye Albert, Brenda, Charles, Dave, Engelbert. Come back soon! ... ... {: .code} There are a lot of new things thrown into this final example that we [can take a deeper look at.](../4/) --- # Ruby in Twenty Minutes Source: https://www.ruby-lang.org/en/documentation/quickstart/4.md So, looking deeper at our new program, notice the initial lines, which begin with a hash mark (#). In Ruby, anything on a line after a hash mark is a comment and is ignored by the interpreter. The first line of the file is a special case, and under a Unix-like operating system tells the shell how to run the file. The rest of the comments are there just for clarity. Our `say_hi` method has become a bit trickier:

# Say hi to everybody
def say_hi
  if @names.nil?
    puts "..."
  elsif @names.respond_to?("each")
    # @names is a list of some kind, iterate!
    @names.each do |name|
      puts "Hello #{name}!"
    end
  else
    puts "Hello #{@names}!"
  end
end

It now looks at the `@names` instance variable to make decisions. If it’s nil, it just prints out three dots. No point greeting nobody, right? ## Cycling and Looping—a.k.a. Iteration If the `@names` object responds to `each`, it is something that you can iterate over, so iterate over it and greet each person in turn. Finally, if `@names` is anything else, just let it get turned into a string automatically and do the default greeting. Let’s look at that iterator in more depth:

@names.each do |name|
  puts "Hello #{name}!"
end

`each` is a method that accepts a block of code then runs that block of code for every element in a list, and the bit between `do` and `end` is just such a block. A block is like an anonymous function or `lambda`. The variable between pipe characters is the parameter for this block. What happens here is that for every entry in a list, `name` is bound to that list element, and then the expression `puts "Hello #{name}!"` is run with that name. Most other programming languages handle going over a list using the `for` loop, which in C looks something like:

for (i=0; i<number_of_elements; i++)
{
  do_something_with(element[i]);
}

This works, but isn’t very elegant. You need a throw-away variable like `i`, have to figure out how long the list is, and have to explain how to walk over the list. The Ruby way is much more elegant, all the housekeeping details are hidden within the `each` method, all you need to do is to tell it what to do with each element. Internally, the `each` method will essentially call `yield "Albert"`, then `yield "Brenda"` and then `yield "Charles"`, and so on. ## Blocks, the Highly Sparkling Glint on the Edge of Ruby The real power of blocks is when dealing with things that are more complicated than lists. Beyond handling simple housekeeping details within the method, you can also handle setup, teardown, and errors—all hidden away from the cares of the user.

# Say bye to everybody
def say_bye
  if @names.nil?
    puts "..."
  elsif @names.respond_to?("join")
    # Join the list elements with commas
    puts "Goodbye #{@names.join(", ")}.  Come back soon!"
  else
    puts "Goodbye #{@names}.  Come back soon!"
  end
end

The `say_bye` method doesn’t use `each`, instead it checks to see if `@names` responds to the `join` method, and if so, uses it. Otherwise, it just prints out the variable as a string. This method of not caring about the actual *type* of a variable, just relying on what methods it supports is known as “Duck Typing”, as in “if it walks like a duck and quacks like a duck…”. The benefit of this is that it doesn’t unnecessarily restrict the types of variables that are supported. If someone comes up with a new kind of list class, as long as it implements the `join` method with the same semantics as other lists, everything will work as planned. ## Kicking Off the Script So, that’s the MegaGreeter class, the rest of the file just calls methods on that class. There’s one final trick to notice, and that’s the line:

if __FILE__ == $0

`__FILE__` is the magic variable that contains the name of the current file. `$0` is the name of the file used to start the program. This check says “If this is the main file being used…” This allows a file to be used as a library, and not to execute code in that context, but if the file is being used as an executable, then execute that code. ## Consider Yourself Introduced So that’s it for the quick tour of Ruby. There’s a lot more to explore, the different control structures that Ruby offers; the use of blocks and `yield`; modules as mixins; and more. I hope this taste of Ruby has left you wanting to learn more. If so, please head on over to our [Documentation](/en/documentation/) area, which rounds up links to manuals and tutorials, all freely available online. --- # Ruby From Other Languages Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages.md When you first look at some Ruby code, it will likely remind you of other programming languages you’ve used. This is on purpose. Much of the syntax is familiar to users of Perl, Python, and Java (among other languages), so if you’ve used those, learning Ruby will be a piece of cake. {: .summary} This document contains two major sections. The first attempts to be a rapid-fire summary of what you can expect to see when going from language *X* to Ruby. The second section tackles the major language features and how they might compare to what you’re already familiar with. ## What to Expect: *Language X* to Ruby * [To Ruby From C and C++](to-ruby-from-c-and-cpp/) * [To Ruby From Java](to-ruby-from-java/) * [To Ruby From Perl](to-ruby-from-perl/) * [To Ruby From PHP](to-ruby-from-php/) * [To Ruby From Python](to-ruby-from-python/) ## Important Language Features And Some Gotchas Here are some pointers and hints on major Ruby features you’ll see while learning Ruby. ### Iteration Two Ruby features that are a bit unlike what you may have seen before, and which take some getting used to, are “blocks” and iterators. Instead of looping over an index (like with C, C++, or pre-1.5 Java), or looping over a list (like Perl’s `for (@a) {...}`, or Python’s `for i in aList: ...`), with Ruby you’ll very often instead see

some_list.each do |this_item|
  # We're inside the block.
  # deal with this_item.
end

For more info on `each` (and its friends `collect`, `find`, `inject`, `sort`, etc.), see `ri Enumerable` (and then `ri Enumerable#some_method`). ### Everything has a value There’s no difference between an expression and a statement. Everything has a value, even if that value is `nil`. This is possible:

x = 10
y = 11
z = if x < y
      true
    else
      false
    end
z # => true

### Symbols are not lightweight Strings Many Ruby newbies struggle with understanding what Symbols are, and what they can be used for. Symbols can best be described as identities. A symbol is all about **who** it is, not **what** it is. Fire up `irb` and see the difference:

irb(main):001:0> :george.object_id == :george.object_id
=> true
irb(main):002:0> "george".object_id == "george".object_id
=> false
irb(main):003:0>

The `object_id` methods returns the identity of an Object. If two objects have the same `object_id`, they are the same (point to the same Object in memory). As you can see, once you have used a Symbol once, any Symbol with the same characters references the same Object in memory. For any given two Symbols that represent the same characters, the `object_id`s match. Now take a look at the String (“george”). The `object_id`s don’t match. That means they’re referencing two different objects in memory. Whenever you use a new String, Ruby allocates memory for it. If you’re in doubt whether to use a Symbol or a String, consider what’s more important: the identity of an object (i.e. a Hash key), or the contents (in the example above, “george”). ### Everything is an Object “Everything is an object” isn’t just hyperbole. Even classes and integers are objects, and you can do the same things with them as with any other object:

# This is the same as
# class MyClass
#   attr_accessor :instance_var
# end
MyClass = Class.new do
  attr_accessor :instance_var
end

### Variable Constants Constants are not really constant. If you modify an already initialized constant, it will trigger a warning, but not halt your program. That isn’t to say you **should** redefine constants, though. ### Naming conventions Ruby enforces some naming conventions. If an identifier starts with a capital letter, it is a constant. If it starts with a dollar sign (`$`), it is a global variable. If it starts with `@`, it is an instance variable. If it starts with `@@`, it is a class variable. Method names, however, are allowed to start with capital letters. This can lead to confusion, as the example below shows:

Constant = 10
def Constant
  11
end

Now `Constant` is 10, but `Constant()` is 11. ### Keyword arguments Like in Python, since Ruby 2.0 methods can be defined using keyword arguments:

def deliver(from: "A", to: nil, via: "mail")
  "Sending from #{from} to #{to} via #{via}."
end

deliver(to: "B")
# => "Sending from A to B via mail."
deliver(via: "Pony Express", from: "B", to: "A")
# => "Sending from B to A via Pony Express."

### The universal truth In Ruby, everything except `nil` and `false` is considered true. In C, Python and many other languages, 0 and possibly other values, such as empty lists, are considered false. Take a look at the following Python code (the example applies to other languages, too):

# in Python
if 0:
  print("0 is true")
else:
  print("0 is false")

This will print “0 is false”. The equivalent Ruby:

# in Ruby
if 0
  puts "0 is true"
else
  puts "0 is false"
end

Prints “0 is true”. ### Access modifiers apply until the end of scope In the following Ruby code,

class MyClass
  private
  def a_method; true; end
  def another_method; false; end
end

You might expect `another_method` to be public. Not so. The `private` access modifier continues until the end of the scope, or until another access modifier pops up, whichever comes first. By default, methods are public:

class MyClass
  # Now a_method is public
  def a_method; true; end

  private

  # another_method is private
  def another_method; false; end
end

`public`, `private` and `protected` are really methods, so they can take parameters. If you pass a Symbol to one of them, that method’s visibility is altered. ### Method access In Java, `public` means a method is accessible by anyone. `protected` means the class’s instances, instances of descendant classes, and instances of classes in the same package can access it, but not anyone else, and `private` means nobody besides the class’s instances can access the method. Ruby differs slightly. `public` is, naturally, public. `private` means the method(s) are accessible only when they can be called without an explicit receiver. Only `self` is allowed to be the receiver of a private method call. `protected` is the one to be on the lookout for. A protected method can be called from a class or descendant class instances, but also with another instance as its receiver. Here is an example (adapted from [The Ruby Language FAQ][faq]):

class Test
  # public by default
  def identifier
    99
  end

  def ==(other)
    identifier == other.identifier
  end
end

t1 = Test.new  # => #<Test:0x34ab50>
t2 = Test.new  # => #<Test:0x342784>
t1 == t2       # => true

# now make `identifier' protected; it still works
# because protected allows `other' as receiver

class Test
  protected :identifier
end

t1 == t2  # => true

# now make `identifier' private

class Test
  private :identifier
end

t1 == t2
# NoMethodError: private method `identifier' called for #<Test:0x342784>

### Classes are open Ruby classes are open. You can open them up, add to them, and change them at any time. Even core classes, like `Integer` or even `Object`, the parent of all objects. Ruby on Rails defines a bunch of methods for dealing with time on `Integer`. Watch:

class Integer
  def hours
    self * 3600 # number of seconds in an hour
  end
  alias hour hours
end

# 14 hours from 00:00 January 1st
# (aka when you finally wake up ;)
Time.mktime(2006, 01, 01) + 14.hours # => Sun Jan 01 14:00:00

### Funny method names In Ruby, methods are allowed to end with question marks or exclamation marks. By convention, methods that answer questions end in question marks (e.g. `Array#empty?`, which returns `true` if the receiver is empty). Potentially “dangerous” methods by convention end with exclamation marks (e.g. methods that modify `self` or the arguments, `exit!`, etc.). Not all methods that change their arguments end with exclamation marks, though. `Array#replace` replaces the contents of an array with the contents of another array. It doesn’t make much sense to have a method like that that **doesn’t** modify self. ### Singleton methods Singleton methods are per-object methods. They are only available on the Object you defined it on.

class Car
  def inspect
    "Cheap car"
  end
end

porsche = Car.new
porsche.inspect # => Cheap car
def porsche.inspect
  "Expensive car"
end

porsche.inspect # => Expensive car

# Other objects are not affected
other_car = Car.new
other_car.inspect # => Cheap car

### Missing methods Ruby doesn’t give up if it can’t find a method that responds to a particular message. It calls the `method_missing` method with the name of the method it couldn’t find and the arguments. By default, `method_missing` raises a NameError exception, but you can redefine it to better fit your application, and many libraries do. Here is an example:

# id is the name of the method called, the * syntax collects
# all the arguments in an array named 'arguments'
def method_missing(id, *arguments)
  puts "Method #{id} was called, but not found. It has " +
       "these arguments: #{arguments.join(", ")}"
end

__ :a, :b, 10
# => Method __ was called, but not found. It has these
# arguments: a, b, 10

The code above just prints the details of the call, but you are free to handle the message in any way that is appropriate. ### Message passing, not function calls A method call is really a **message** to another object:

# This
1 + 2
# Is the same as this ...
1.+(2)
# Which is the same as this:
1.send "+", 2

### Blocks are Objects, they just don’t know it yet Blocks (closures, really) are heavily used by the standard library. To call a block, you can either use `yield`, or make it a `Proc` by appending a special argument to the argument list, like so:

def block(&the_block)
  # Inside here, the_block is the block passed to the method
  the_block # return the block
end
adder = block { |a, b| a + b }
# adder is now a Proc object
adder.class # => Proc

You can create blocks outside of method calls, too, by calling `Proc.new` with a block or calling the `lambda` method. Similarly, methods are also Objects in the making:

method(:puts).call "puts is an object!"
# => puts is an object!

### Operators are syntactic sugar Most operators in Ruby are just syntactic sugar (with some precedence rules) for method calls. You can, for example, override Integer’s `+` method:

class Integer
  # You can, but please don't do this
  def +(other)
    self - other
  end
end

You don’t need C++’s `operator+`, etc. You can even have array-style access if you define the `[]` and `[]=` methods. To define the unary + and - (think +1 and -2), you must define the `+@` and `-@` methods, respectively. The operators below are **not** syntactic sugar, though. They are not methods, and cannot be redefined:

=, .., ..., not, &&, and, ||, or, ::

In addition, `+=`, `*=` etc. are just abbreviations for `var = var + other_var`, `var = var * other_var`, etc. and therefore cannot be redefined. ## Finding Out More When you are ready for more Ruby knowledge, see our [Documentation](/en/documentation/) section. [faq]: http://ruby-doc.org/docs/ruby-doc-bundle/FAQ/FAQ.html --- # To Ruby From C and C++ Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-c-and-cpp.md It’s difficult to write a bulleted list describing how your code will be different in Ruby from C or C++ because it’s quite a large difference. One reason is that the Ruby runtime does so much for you. Ruby seems about as far as you can get from C’s “no hidden mechanism” principle—the whole point of Ruby is to make the human’s job easier at the expense of making the runtime shoulder more of the work. Unless or until you profile your code for optimization, you don’t need to care one whit about “keeping your compiler happy” when using Ruby. That said, for one thing, you can expect your Ruby code to execute much more slowly than “equivalent” C or C++ code. At the same time, your head will spin at how rapidly you can get a Ruby program up and running, as well as at how few lines of code it will take to write it. Ruby is much much simpler than C++—it will spoil you rotten. Ruby is dynamically typed, rather than statically typed—the runtime does as much as possible at run-time. For example, you don’t need to know what modules your Ruby program will “link to” (that is, load and use) or what methods it will call ahead of time. Happily, it turns out that Ruby and C have a healthy symbiotic relationship. Ruby supports so-called “extension modules”. These are modules that you can use from your Ruby programs (and which, from the outside, will look and act just like any other Ruby module), but which are written in C. In this way, you can compartmentalize the performance-critical parts of your Ruby software, and smelt those down to pure C. And, of course, Ruby itself is written in C. ### Similarities with C As with C, in Ruby,... * You may program procedurally if you like (but it will still be object-oriented behind the scenes). * Most of the operators are the same (including the compound assignment and also bitwise operators). Though, Ruby doesn’t have `++` or `--`. * You’ve got `__FILE__` and `__LINE__`. * You can also have constants, though there’s no special `const` keyword. Const-ness is enforced by a naming convention instead— names starting with a capital letter are for constants. * Strings go in double-quotes. * Strings are mutable. * Just like man pages, you can read most docs in your terminal window—though using the `ri` command. * You’ve got the same sort of command-line debugger available. ### Similarities with C++ As with C++, in Ruby,... * You’ve got mostly the same operators (even `::`). `<<` is often used for appending elements to a list. One note though: with Ruby you never use `->`—it’s always just `.`. * `public`, `private`, and `protected` do similar jobs. * Inheritance syntax is still only one character, but it’s `<` instead of `:`. * You may put your code into “modules”, similar to how `namespace` in C++ is used. * Exceptions work in a similar manner, though the keyword names have been changed to protect the innocent. ### Differences from C Unlike C, in Ruby,... * You don’t need to compile your code. You just run it directly. * Objects are strongly typed (and variable names themselves have no type at all). * There’s no macros or preprocessor. No casts. No pointers (nor pointer arithmetic). No typedefs, sizeof, nor enums. * There are no header files. You just define your functions (usually referred to as “methods”) and classes in the main source code files. * There’s no `#define`. Just use constants instead. * All variables live on the heap. Further, you don’t need to free them yourself—the garbage collector takes care of that. * Arguments to methods (i.e. functions) are passed by value, where the values are always object references. * It’s `require 'foo'` instead of `#include ` or `#include "foo"`. * You cannot drop down to assembly. * There’s no semicolons ending lines. * You go without parentheses for `if` and `while` condition expressions. * Parentheses for method (i.e. function) calls are often optional. * You don’t usually use braces—just end multi-line constructs (like `while` loops) with an `end` keyword. * The `do` keyword is for so-called “blocks”. There’s no “do statement” like in C. * The term “block” means something different. It’s for a block of code that you associate with a method call so the method body can call out to the block while it executes. * There are no variable declarations. You just assign to new names on-the-fly when you need them. * When tested for truth, only `false` and `nil` evaluate to a false value. Everything else is true (including `0`, `0.0`, and `"0"`). * There is no `char`—they are just 1-letter strings. * Strings don’t end with a null byte. * Array literals go in brackets instead of braces. * Arrays just automatically get bigger when you stuff more elements into them. * If you add two arrays, you get back a new and bigger array (of course, allocated on the heap) instead of doing pointer arithmetic. * More often than not, everything is an expression (that is, things like `while` statements actually evaluate to an rvalue). ### Differences from C++ Unlike C++, in Ruby,... * There’s no explicit references. That is, in Ruby, every variable is just an automatically dereferenced name for some object. * Objects are strongly but *dynamically* typed. The runtime discovers *at runtime* if that method call actually works. * The “constructor” is called `initialize` instead of the class name. * All methods are always virtual. * “Class” (static) variable names always begin with `@@` (as in `@@total_widgets`). * You don’t directly access member variables—all access to public member variables (known in Ruby as attributes) is via methods. * It’s `self` instead of `this`. * Some methods end in a ’?’ or a ’!’. It’s actually part of the method name. * There’s no multiple inheritance per se. Though Ruby has “mixins” (i.e. you can “inherit” all instance methods of a module). * There are some enforced case-conventions (ex. class names start with a capital letter, variables start with a lowercase letter). * Parentheses for method calls are usually optional. * You can re-open a class anytime and add more methods. * There’s no need of C++ templates (since you can assign any kind of object to a given variable, and types get figured out at runtime anyway). No casting either. * Iteration is done a bit differently. In Ruby, you don’t use a separate iterator object (like `vector::const_iterator iter`). Instead you use an iterator method of the container object (like `each`) that takes a block of code to which it passes successive elements. * There’s only two container types: `Array` and `Hash`. * There’s no type conversions. With Ruby though, you’ll probably find that they aren’t necessary. * Multithreading is built-in, but as of Ruby 1.8 they are “green threads” (implemented only within the interpreter) as opposed to native threads. * A unit testing lib comes standard with Ruby. --- # To Ruby From Java Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-java.md Java is mature. It’s tested. And it’s fast (contrary to what the anti-Java crowd may still claim). It’s also quite verbose. Going from Java to Ruby, expect your code size to shrink down considerably. You can also expect it to take less time to knock together quick prototypes. ### Similarities As with Java, in Ruby,... * Memory is managed for you via a garbage collector. * Objects are strongly typed. * There are public, private, and protected methods. * There are embedded doc tools (Ruby’s is called RDoc). The docs generated by rdoc look very similar to those generated by javadoc. ### Differences Unlike Java, in Ruby,... * You don’t need to compile your code. You just run it directly. * There are several different popular third-party GUI toolkits. Ruby users can try [WxRuby][1], [FXRuby][2], [Ruby-GNOME][3], or [Ruby Tk](https://github.com/ruby/tk) for example. * You use the `end` keyword after defining things like classes, instead of having to put braces around blocks of code. * You have `require` instead of `import`. * All member variables are private. From the outside, you access everything via methods. * Parentheses in method calls are usually optional and often omitted. * Everything is an object, including numbers like 2 and 3.14159. * There’s no static type checking. * Variable names are just labels. They don’t have a type associated with them. * There are no type declarations. You just assign to new variable names as-needed and they just “spring up” (i.e. `a = [1,2,3]` rather than `int[] a = {1,2,3};`). * There’s no casting. Just call the methods. Your unit tests should tell you before you even run the code if you’re going to see an exception. * It’s `foo = Foo.new("hi")` instead of `Foo foo = new Foo("hi")`. * The constructor is always named “initialize” instead of the name of the class. * You have “mixins” instead of interfaces. * YAML tends to be favored over XML. * It’s `nil` instead of `null`. * `==` and `equals()` are handled differently in Ruby. Use `==` when you want to test equivalence in Ruby (`equals()` in Java). Use `equal?()` when you want to know if two objects are the same (`==` in Java). [1]: https://github.com/mcorino/wxRuby3 [2]: https://github.com/larskanis/fxruby [3]: https://ruby-gnome.github.io/ --- # To Ruby From Perl Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-perl.md Perl is awesome. Perl’s docs are awesome. The Perl community is … awesome. For those Perlers who long for elegant OO features built-in from the beginning, Ruby may be for you. ### Similarities As with Perl, in Ruby,... * You’ve got a package management system, somewhat like CPAN (though it’s called [RubyGems][1]). * Regexes are built right in. Bon appétit! * There’s a fairly large number of commonly-used built-ins. * Parentheses are often optional. * Strings work basically the same. * There’s a general delimited string and regex quoting syntax similar to Perl’s. It looks like `%q{this}` (single-quoted), or `%Q{this}` (double-quoted), and `%w{this for a single-quoted list of words}`. You `%Q|can|` `%Q(use)` `%Q^other^` delimiters if you like. * You’ve got double-quotish variable interpolation, though it `"looks #{like} this"` (and you can put any Ruby code you like inside that `#{}`). * Shell command expansion uses `` `backticks` ``. * You’ve got embedded doc tools (Ruby’s is called rdoc). ### Differences Unlike Perl, in Ruby,... * You don’t have the context-dependent rules like with Perl. * A variable isn’t the same as the object to which it refers. Instead, it’s always just a reference to an object. * Although `$` and `@` are used as the first character in variable names sometimes, rather than indicating type, they indicate scope (`$` for globals, `@` for object instance, and `@@` for class attributes). * Array literals go in brackets instead of parentheses. * Composing lists of other lists does not flatten them into one big list. Instead you get an array of arrays. * It’s `def` instead of `sub`. * There’s no semicolons needed at the end of each line. Incidentally, you end things like function definitions, class definitions, and case statements with the `end` keyword. * Objects are strongly typed. You’ll be manually calling `foo.to_i`, `foo.to_s`, etc., if you need to convert between types. * There’s no `eq`, `ne`, `lt`, `gt`, `ge`, nor `le`. * There’s no diamond operator (`<>`). You usually use `IO.some_method` instead. * The fat comma `=>` is only used for hash literals. * There’s no `undef`. In Ruby you have `nil`. `nil` is an object (like anything else in Ruby). It’s not the same as an undefined variable. It evaluates to `false` if you treat it like a boolean. * When tested for truth, only `false` and `nil` evaluate to a false value. Everything else is true (including `0`, `0.0`, and `"0"`). * There’s no [PerlMonks][2]. Though the ruby-talk mailing list is a very helpful place. [1]: http://guides.rubygems.org [2]: http://www.perlmonks.org/ --- # To Ruby From PHP Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-php.md PHP is in widespread use for web applications, but if you want to use Ruby on Rails or just want a language that’s more tailored for general use, Ruby is worth a look. ### Similarities As in PHP, in Ruby… * Ruby is dynamically typed, like in PHP, so you don’t need to worry about having to declare variables. * There are classes, and you can control access to them like in PHP 5 (`public`, `protected` and `private`). * Some variables start with $, like in PHP (but not all). * There’s `eval`, too. * You can use string interpolation. Instead of doing `"$foo is a $bar"`, you can do `"#{foo} is a #{bar}"`—like in PHP, this doesn’t apply for single-quoted strings. * There’s heredocs. * Ruby has exceptions, like PHP 5. * There’s a fairly large standard library. * Arrays and hashes work like expected, if you exchange `array()` for `{` and `}`\: `array('a' => 'b')` becomes `{'a' => 'b'}`. * `true` and `false` behave like in PHP, but `null` is called `nil`. ### Differences Unlike in PHP, in Ruby… * There’s strong typing. You’ll need to call `to_s`, `to_i` etc. to convert between strings, integers and so on, instead of relying on the language to do it. * Strings, numbers, arrays, hashes, etc. are objects. Instead of calling `abs(-1)` it’s `-1.abs`. * Parentheses are optional in method calls, except to clarify which parameters go to which method calls. * The standard library and extensions are organized in modules and classes. * Reflection is an inherent capability of objects, you don’t need to use `Reflection` classes like in PHP 5. * Variables are references. * There’s no `abstract` classes or `interface`s. * Hashes and arrays are not interchangeable. * Only `false` and `nil` are false: `0`, `array()` and `""` are all true in conditionals. * Almost everything is a method call, even `raise` (`throw` in PHP). --- # To Ruby From Python Source: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/to-ruby-from-python.md Python is another very nice general purpose programming language. Going from Python to Ruby, you’ll find that there’s a little bit more syntax to learn than with Python. ### Similarities As with Python, in Ruby,... * There’s an interactive prompt (called `irb`). * You can read docs on the command line (with the `ri` command instead of `pydoc`). * There are no special line terminators (except the usual newline). * String literals can span multiple lines like Python’s triple-quoted strings. * Brackets are for lists, and braces are for dicts (which, in Ruby, are called “hashes”). * Arrays work the same (adding them makes one long array, but composing them like this `a3 = [ a1, a2 ]` gives you an array of arrays). * Objects are strongly and dynamically typed. * Everything is an object, and variables are just references to objects. * Although the keywords are a bit different, exceptions work about the same. * You’ve got embedded doc tools (Ruby’s is called rdoc). * There is good support for functional programming with first-class functions, anonymous functions, and closures. ### Differences Unlike Python, in Ruby,... * Strings are mutable. * You can make constants (variables whose value you don’t intend to change). * There are some enforced case-conventions (ex. class names start with a capital letter, variables start with a lowercase letter). * There’s only one kind of list container (an Array), and it’s mutable. * Double-quoted strings allow escape sequences (like `\t`) and a special “expression substitution” syntax (which allows you to insert the results of Ruby expressions directly into other strings without having to `"add " + "strings " + "together"`). Single-quoted strings are like Python’s `r"raw strings"`. * There are no “new style” and “old style” classes. Just one kind. (Python 3+ doesn’t have this issue, but it isn’t fully backward compatible with Python 2.) * You never directly access attributes. With Ruby, it’s all method calls. * Parentheses for method calls are usually optional. * There’s `public`, `private`, and `protected` to enforce access, instead of Python’s `_voluntary_` underscore `__convention__`. * “mixins” are used instead of multiple inheritance. * You can add or modify the methods of built-in classes. Both languages let you open up and modify classes at any point, but Python prevents modification of built-ins — Ruby does not. * You’ve got `true` and `false` instead of `True` and `False` (and `nil` instead of `None`). * When tested for truth, only `false` and `nil` evaluate to a false value. Everything else is true (including `0`, `0.0`, `""`, and `[]`). * It’s `elsif` instead of `elif`. * It’s `require` instead of `import`. Otherwise though, usage is the same. * The usual-style comments on the line(s) *above* things (instead of docstrings below them) are used for generating docs. * There are a number of shortcuts that, although give you more to remember, you quickly learn. They tend to make Ruby fun and very productive. * There’s no way to unset a variable once set (like Python’s `del` statement). You can reset a variable to `nil`, allowing the old contents to be garbage collected, but the variable will remain in the symbol table as long as it is in scope. * The `yield` keyword behaves differently. In Python it will return execution to the scope outside the function's invocation. External code is responsible for resuming the function. In Ruby `yield` will execute another function that has been passed as the final argument, then immediately resume. * Python supports just one kind of anonymous functions, lambdas, while Ruby contains blocks, Procs, and lambdas. --- # Success Stories Source: https://www.ruby-lang.org/en/documentation/success-stories.md Many people use Ruby in their daily jobs. Others just as a hobby. Here you’ll find a small sample of real world usage of Ruby. {: .summary} #### Simulations * [NASA Langley Research Center][1] uses Ruby to conduct simulations. * A research group in [Motorola][2] uses Ruby to script a simulator, both to generate scenarios and to post process the data. #### 3D Modeling * [Google SketchUp][3] is a 3D modeling application that uses Ruby for its macro scripting API. #### Business * [Toronto Rehab][4] uses a RubyWebDialogs-based app to manage and track on-call and on-site support for the IT help desk and IT operations teams. #### Robotics * At MORPHA project, Ruby was used to implement the reactive control part for the Siemens service robot. #### Telephony * Ruby is being used within Lucent on a 3G wireless telephony product. #### System Administration * Ruby was used to write the central data collection portion of [Level 3 Communications][8] Unix Capacity and Planning system that gathers performance statistics from over 1700 Unix (Solaris and Linux) servers scattered around the globe. #### Web Applications * [Basecamp][9], a web-based project management application, is programmed entirely in Ruby. * [A List Apart][10], a magazine for people who make websites that has been around since 1997, has recently been revamped and uses a custom application built with Ruby on Rails. #### Security * The [Metasploit Framework][metasploit], a community open source project managed by [Rapid7][rapid7], is a free penetration testing platform that helps IT professionals assess the security of their networks and applications. The Metasploit Project consists of over 700,000 lines of code and has been downloaded over a million times in 2010. The commercial editions developed by Rapid7 are also based on Ruby. * The [Arachni Web Application Security Scanner][arachni] is a free, modular, high-performance Ruby framework aimed towards helping penetration testers and administrators evaluate the security of modern web applications. [1]: http://www.larc.nasa.gov/ [2]: http://www.motorola.com [3]: http://www.sketchup.com/ [4]: https://www.uhn.ca/TorontoRehab [8]: http://www.level3.com/ [9]: https://www.basecamp.com [10]: http://www.alistapart.com [metasploit]: http://www.metasploit.com [rapid7]: http://www.rapid7.com [arachni]: http://www.arachni-scanner.com/ --- # Download Ruby Source: https://www.ruby-lang.org/en/downloads.md Here you can get the latest Ruby distributions in your favorite flavor. The current stable version is 4.0.7. Please be sure to read [Ruby’s License][license]. {: .summary} ### Ways of Installing Ruby We have several tools on each major platform to install Ruby: * On Linux/UNIX, you can use the package management system of your distribution or third-party tools ([rbenv][rbenv] and [RVM][rvm]). * On macOS machines, you can use third-party tools ([rbenv][rbenv] and [RVM][rvm]). * On Windows machines, you can use [RubyInstaller][rubyinstaller]. See the [Installation][installation] page for details on using package management systems or third-party tools. Of course, you can also install Ruby from source on all major platforms. ### Compiling Ruby — Source Code Installing from the source code is a great solution for when you are comfortable enough with your platform and perhaps need specific settings for your environment. It’s also a good solution in the event that there are no other premade packages for your platform. See the [Installation][installation] page for details on building Ruby from source. If you have an issue compiling Ruby, consider using one of the third party tools mentioned above. They may help you. * **Stable releases:** * [Ruby 4.0.7](https://cache.ruby-lang.org/pub/ruby/4.0/ruby-4.0.7.tar.gz)
sha256: 911ace20f90d068ca0e4dda6d0e4f0f81e52e52f2dd4f4004c721e253412e82d * [Ruby 3.4.10](https://cache.ruby-lang.org/pub/ruby/3.4/ruby-3.4.10.tar.gz)
sha256: ecee2d072a14f2d14347dd56dfd8fe5c3130abf5117bfaacbda0f4ef9cc429ec * [Ruby 3.3.12](https://cache.ruby-lang.org/pub/ruby/3.3/ruby-3.3.12.tar.gz)
sha256: b06d63beae271933033e27f0a389bc582a009e7845357d44365c39de525a051b * [Ruby 3.2.11](https://cache.ruby-lang.org/pub/ruby/3.2/ruby-3.2.11.tar.gz)
sha256: b3eeabd6636f334531db3ffdc3229eb05e524740e6c84fdc043720573cf2f8b2 * **Not maintained anymore (EOL):** * [Ruby 3.1.7](https://cache.ruby-lang.org/pub/ruby/3.1/ruby-3.1.7.tar.gz)
sha256: 0556acd69f141ddace03fa5dd8d76e7ea0d8f5232edf012429579bcdaab30e7b * **Snapshots:** * [Stable Snapshot of ruby_4_0 branch](https://cache.ruby-lang.org/pub/ruby/snapshot/snapshot-ruby_4_0.tar.gz): This is a tarball of the latest snapshot of the current `ruby_4_0` branch. * [Stable Snapshot of ruby_3_4 branch](https://cache.ruby-lang.org/pub/ruby/snapshot/snapshot-ruby_3_4.tar.gz): This is a tarball of the latest snapshot of the current `ruby_3_4` branch. * [Stable Snapshot of ruby_3_3 branch](https://cache.ruby-lang.org/pub/ruby/snapshot/snapshot-ruby_3_3.tar.gz): This is a tarball of the latest snapshot of the current `ruby_3_3` branch. * [Stable Snapshot of ruby_3_2 branch](https://cache.ruby-lang.org/pub/ruby/snapshot/snapshot-ruby_3_2.tar.gz): This is a tarball of the latest snapshot of the current `ruby_3_2` branch. * [Nightly Snapshot](https://cache.ruby-lang.org/pub/ruby/snapshot/snapshot-master.tar.gz): This is a tarball of whatever is in Git, made nightly. This may contain bugs or other issues, use at your own risk! For more information about specific releases, particularly older releases or previews, see the [Releases page][releases]. Information about the current maintenance status of the various Ruby branches can be found on the [Branches page][branches]. For information about the Ruby Subversion and Git repositories, see our [Ruby Core](/en/community/ruby-core/) page. The Ruby source is available from a worldwide set of [Mirror Sites][mirrors]. Please try to use a mirror that is near you. [license]: /en/about/license.txt [installation]: /en/documentation/installation/ [releases]: /en/downloads/releases/ [branches]: /en/downloads/branches/ [mirrors]: /en/downloads/mirrors/ [rvm]: http://rvm.io/ [rbenv]: https://github.com/rbenv/rbenv [rubyinstaller]: https://rubyinstaller.org/ --- # Ruby Maintenance Branches Source: https://www.ruby-lang.org/en/downloads/branches.md This page lists the current maintenance status of the various Ruby branches. {: .summary} For more information about specific releases see the [Releases page](../releases/). This is a preliminary list of Ruby branches and their maintenance status. The shown dates are inferred from the English versions of release posts or EOL announcements. The Ruby branches or release series are categorized below into the following phases: * **normal maintenance** (bug fix): Branch receives general bug fixes and security fixes. * **security maintenance** (security fix): Only security fixes are backported to this branch. * **eol** (end-of-life): Branch is not supported by the ruby-core team any longer and does not receive any fixes. No further patch release will be released.

Ruby Lifecycle Timelines

### Ruby 4.0 status: normal maintenance
release date: 2025-12-25
normal maintenance until: TBD
EOL: TBD ### Ruby 3.4 status: normal maintenance
release date: 2024-12-25
normal maintenance until: TBD
EOL: TBD ### Ruby 3.3 status: security maintenance
release date: 2023-12-25
normal maintenance until: 2026-04-01
EOL: 2027-03-31 (expected) ### Ruby 3.2 status: eol
release date: 2022-12-25
normal maintenance until: 2025-04-01
EOL: 2026-04-01 ### Ruby 3.1 status: eol
release date: 2021-12-25
normal maintenance until: 2024-04-01
EOL: 2025-03-26 ### Ruby 3.0 status: eol
release date: 2020-12-25
normal maintenance until: 2023-04-01
EOL: 2024-04-23 ### Ruby 2.7 status: eol
release date: 2019-12-25
normal maintenance until: 2022-04-01
EOL: 2023-03-31 ### Ruby 2.6 status: eol
release date: 2018-12-25
normal maintenance until: 2021-04-01
EOL: 2022-04-12 ### Ruby 2.5 status: eol
release date: 2017-12-25
normal maintenance until: 2020-04-01
EOL: 2021-04-05 ### Ruby 2.4 status: eol
release date: 2016-12-25
normal maintenance until: 2019-04-01
EOL: 2020-03-31 ### Ruby 2.3 status: eol
release date: 2015-12-25
normal maintenance until: 2018-03-28
EOL: 2019-03-31 ### Ruby 2.2 status: eol
release date: 2014-12-25
normal maintenance until: 2017-03-28
EOL: 2018-03-31 ### Ruby 2.1 status: eol
release date: 2013-12-25
normal maintenance until: 2016-03-31
EOL: 2017-03-31 ### Ruby 2.0.0 status: eol
release date: 2013-02-24
normal maintenance until: 2016-02-24
EOL: 2016-02-24 ### Ruby 1.9.3 status: eol
release date: 2011-10-31
normal maintenance until: 2014-02-24
EOL: 2015-02-23 --- # Mirror Sites Source: https://www.ruby-lang.org/en/downloads/mirrors.md The Ruby source is available from a worldwide set of mirror sites. Please try to use a mirror that is near you. {: .summary} ### Mirror sites via HTTP * [CDN][mirror-https-cdn] (fastly.com) * [Japan][mirror-http-jp-ring] (RingServer) * [Holland][mirror-http-nl] (XS4ALL) - only release packages * [France][mirror-http-fr] (cyberbits.eu) * [China 2][mirror-http-cn2] (Ruby China) * [South Korea][mirror-http-kr] (Korea FreeBSD Users Group) ### Mirror sites via FTP * [Japan][mirror-ftp-jp-ring] (RingServer) * [Japan 3][mirror-ftp-jp3] (IIJ) * [South Korea][mirror-ftp-kr] (Korea FreeBSD Users Group) * [Germany][mirror-ftp-de] (FU Berlin) * [Greece][mirror-ftp-gr] (ntua.gr) ### Mirror sites via rsync * [France][mirror-rsync-fr] (cyberbits.eu) * [South Korea][mirror-rsync-kr] (Korea FreeBSD Users Group) [mirror-https-cdn]: https://cache.ruby-lang.org/pub/ruby/ [mirror-http-jp-ring]: http://www.ring.gr.jp/pub/lang/ruby/ [mirror-http-nl]: http://www.xs4all.nl/~hipster/lib/mirror/ruby/ [mirror-http-fr]: https://mirror.cyberbits.eu/ruby/ [mirror-http-cn2]: https://cache.ruby-china.com/pub/ruby/ [mirror-http-kr]: http://ftp.kr.freebsd.org/pub/ruby/ [mirror-ftp-jp-ring]: ftp://ftp.ring.gr.jp/pub/lang/ruby/ [mirror-ftp-jp3]: ftp://ftp.iij.ad.jp/pub/lang/ruby/ [mirror-ftp-kr]: ftp://ftp.kr.freebsd.org/pub/ruby/ [mirror-ftp-de]: ftp://ftp.fu-berlin.de/unix/languages/ruby/ [mirror-ftp-gr]: ftp://ftp.ntua.gr/pub/lang/ruby/ [mirror-rsync-fr]: rsync://rsync.cyberbits.eu/ruby/ [mirror-rsync-kr]: rsync://rsync.kr.freebsd.org/ruby/ --- # Ruby Releases Source: https://www.ruby-lang.org/en/downloads/releases.md This page lists individual Ruby releases. {: .summary} For information about the current maintenance status of the various Ruby branches see the [Branches page](../branches/). ### Ruby releases by version number This is a list of Ruby releases. The shown dates correspond to the publication dates of the English versions of release posts and may differ from the actual creation dates of the source tarballs.

Release Version	Release Date	Download URL	Release Notes
Ruby 4.0.7	2026-09-15	download	more...
Ruby 3.3.12	2026-07-16	download	more...
Ruby 4.0.6	2026-07-14	download	more...
Ruby 3.4.10	2026-06-30	download	more...
Ruby 4.0.5	2026-05-20	download	more...
Ruby 4.0.4	2026-05-11	download	more...
Ruby 4.0.3	2026-04-21	download	more...
Ruby 3.2.11	2026-03-27	download	more...
Ruby 3.3.11	2026-03-26	download	more...
Ruby 4.0.2	2026-03-16	download	more...
Ruby 3.4.9	2026-03-11	download	more...
Ruby 3.2.10	2026-01-14	download	more...
Ruby 4.0.1	2026-01-13	download	more...
Ruby 4.0.0	2025-12-25	download	more...
Ruby 4.0.0-preview3	2025-12-18	download	more...
Ruby 3.4.8	2025-12-17	download	more...
Ruby 4.0.0-preview2	2025-11-17	download	more...
Ruby 3.3.10	2025-10-23	download	more...
Ruby 3.4.7	2025-10-07	download	more...
Ruby 3.4.6	2025-09-16	download	more...
Ruby 3.3.9	2025-07-24	download	more...
Ruby 3.2.9	2025-07-24	download	more...
Ruby 3.4.5	2025-07-15	download	more...
Ruby 3.4.4	2025-05-14	download	more...
Ruby 3.5.0-preview1	2025-04-18	download	more...
Ruby 3.4.3	2025-04-14	download	more...
Ruby 3.3.8	2025-04-09	download	more...
Ruby 3.2.8	2025-03-26	download	more...
Ruby 3.1.7	2025-03-26	download	more...
Ruby 3.4.2	2025-02-14	download	more...
Ruby 3.2.7	2025-02-04	download	more...
Ruby 3.3.7	2025-01-15	download	more...
Ruby 3.4.1	2024-12-25	download	more...
Ruby 3.4.0	2024-12-25	download	more...
Ruby 3.4.0-rc1	2024-12-12	download	more...
Ruby 3.3.6	2024-11-05	download	more...
Ruby 3.2.6	2024-10-30	download	more...
Ruby 3.4.0-preview2	2024-10-07	download	more...
Ruby 3.3.5	2024-09-03	download	more...
Ruby 3.2.5	2024-07-26	download	more...
Ruby 3.3.4	2024-07-09	download	more...
Ruby 3.3.3	2024-06-12	download	more...
Ruby 3.3.2	2024-05-30	download	more...
Ruby 3.1.6	2024-05-29	download	more...
Ruby 3.4.0-preview1	2024-05-16	download	more...
Ruby 3.3.1	2024-04-23	download	more...
Ruby 3.2.4	2024-04-23	download	more...
Ruby 3.1.5	2024-04-23	download	more...
Ruby 3.0.7	2024-04-23	download	more...
Ruby 3.2.3	2024-01-18	download	more...
Ruby 3.3.0	2023-12-25	download	more...
Ruby 3.3.0-rc1	2023-12-11	download	more...
Ruby 3.3.0-preview3	2023-11-12	download	more...
Ruby 3.3.0-preview2	2023-09-14	download	more...
Ruby 3.3.0-preview1	2023-05-12	download	more...
Ruby 3.2.2	2023-03-30	download	more...
Ruby 3.1.4	2023-03-30	download	more...
Ruby 3.0.6	2023-03-30	download	more...
Ruby 2.7.8	2023-03-30	download	more...
Ruby 3.2.1	2023-02-08	download	more...
Ruby 3.2.0	2022-12-25	download	more...
Ruby 3.2.0-rc1	2022-12-06	download	more...
Ruby 3.1.3	2022-11-24	download	more...
Ruby 3.0.5	2022-11-24	download	more...
Ruby 2.7.7	2022-11-24	download	more...
Ruby 3.2.0-preview3	2022-11-11	download	more...
Ruby 3.2.0-preview2	2022-09-09	download	more...
Ruby 3.1.2	2022-04-12	download	more...
Ruby 3.0.4	2022-04-12	download	more...
Ruby 2.7.6	2022-04-12	download	more...
Ruby 2.6.10	2022-04-12	download	more...
Ruby 3.2.0-preview1	2022-04-03	download	more...
Ruby 3.1.1	2022-02-18	download	more...
Ruby 3.1.0	2021-12-25	download	more...
Ruby 3.0.3	2021-11-24	download	more...
Ruby 2.7.5	2021-11-24	download	more...
Ruby 2.6.9	2021-11-24	download	more...
Ruby 3.1.0-preview1	2021-11-09	download	more...
Ruby 3.0.2	2021-07-07	download	more...
Ruby 2.7.4	2021-07-07	download	more...
Ruby 2.6.8	2021-07-07	download	more...
Ruby 3.0.1	2021-04-05	download	more...
Ruby 2.7.3	2021-04-05	download	more...
Ruby 2.6.7	2021-04-05	download	more...
Ruby 2.5.9	2021-04-05	download	more...
Ruby 3.0.0	2020-12-25	download	more...
Ruby 3.0.0-rc1	2020-12-20	download	more...
Ruby 3.0.0-preview2	2020-12-08	download	more...
Ruby 2.7.2	2020-10-02	download	more...
Ruby 3.0.0-preview1	2020-09-25	download	more...
Ruby 2.7.1	2020-03-31	download	more...
Ruby 2.6.6	2020-03-31	download	more...
Ruby 2.5.8	2020-03-31	download	more...
Ruby 2.4.10	2020-03-31	download	more...
Ruby 2.7.0	2019-12-25	download	more...
Ruby 2.7.0-rc2	2019-12-21	download	more...
Ruby 2.7.0-rc1	2019-12-17	download	more...
Ruby 2.7.0-preview3	2019-11-23	download	more...
Ruby 2.7.0-preview2	2019-10-22	download	more...
Ruby 2.4.9	2019-10-02	download	more...
Ruby 2.6.5	2019-10-01	download	more...
Ruby 2.5.7	2019-10-01	download	more...
Ruby 2.4.8	2019-10-01	download	more...
Ruby 2.6.4	2019-08-28	download	more...
Ruby 2.5.6	2019-08-28	download	more...
Ruby 2.4.7	2019-08-28	download	more...
Ruby 2.7.0-preview1	2019-05-30	download	more...
Ruby 2.6.3	2019-04-17	download	more...
Ruby 2.4.6	2019-04-01	download	more...
Ruby 2.5.5	2019-03-15	download	more...
Ruby 2.6.2	2019-03-13	download	more...
Ruby 2.5.4	2019-03-13	download	more...
Ruby 2.6.1	2019-01-30	download	more...
Ruby 2.6.0	2018-12-25	download	more...
Ruby 2.6.0-rc2	2018-12-15	download	more...
Ruby 2.6.0-rc1	2018-12-06	download	more...
Ruby 2.6.0-preview3	2018-11-06	download	more...
Ruby 2.5.3	2018-10-18	download	more...
Ruby 2.5.2	2018-10-17	download	more...
Ruby 2.4.5	2018-10-17	download	more...
Ruby 2.3.8	2018-10-17	download	more...
Ruby 2.6.0-preview2	2018-05-31	download	more...
Ruby 2.5.1	2018-03-28	download	more...
Ruby 2.4.4	2018-03-28	download	more...
Ruby 2.3.7	2018-03-28	download	more...
Ruby 2.2.10	2018-03-28	download	more...
Ruby 2.6.0-preview1	2018-02-24	download	more...
Ruby 2.5.0	2017-12-25	download	more...
Ruby 2.5.0-rc1	2017-12-14	download	more...
Ruby 2.4.3	2017-12-14	download	more...
Ruby 2.3.6	2017-12-14	download	more...
Ruby 2.2.9	2017-12-14	download	more...
Ruby 2.5.0-preview1	2017-10-10	download	more...
Ruby 2.4.2	2017-09-14	download	more...
Ruby 2.3.5	2017-09-14	download	more...
Ruby 2.2.8	2017-09-14	download	more...
Ruby 2.3.4	2017-03-30	download	more...
Ruby 2.2.7	2017-03-28	download	more...
Ruby 2.4.1	2017-03-22	download	more...
Ruby 2.4.0	2016-12-25	download	more...
Ruby 2.4.0-rc1	2016-12-12	download	more...
Ruby 2.3.3	2016-11-21	download	more...
Ruby 2.3.2	2016-11-15	download	more...
Ruby 2.2.6	2016-11-15	download	more...
Ruby 2.4.0-preview3	2016-11-09	download	more...
Ruby 2.4.0-preview2	2016-09-08	download	more...
Ruby 2.4.0-preview1	2016-06-20	download	more...
Ruby 2.3.1	2016-04-26	download	more...
Ruby 2.2.5	2016-04-26	download	more...
Ruby 2.1.10	2016-04-01	download	more...
Ruby 2.1.9	2016-03-30	download	more...
Ruby 2.3.0	2015-12-25	download	more...
Ruby 2.2.4	2015-12-16	download	more...
Ruby 2.1.8	2015-12-16	download	more...
Ruby 2.0.0-p648	2015-12-16	download	more...
Ruby 2.3.0-preview2	2015-12-11	download	more...
Ruby 2.3.0-preview1	2015-11-11	download	more...
Ruby 2.2.3	2015-08-18	download	more...
Ruby 2.1.7	2015-08-18	download	more...
Ruby 2.0.0-p647	2015-08-18	download	more...
Ruby 2.2.2	2015-04-13	download	more...
Ruby 2.1.6	2015-04-13	download	more...
Ruby 2.0.0-p645	2015-04-13	download	more...
Ruby 2.2.1	2015-03-03	download	more...
Ruby 2.0.0-p643	2015-02-25	download	more...
Ruby 2.2.0	2014-12-25	download	more...
Ruby 2.2.0-rc1	2014-12-18	download	more...
Ruby 2.2.0-preview2	2014-11-28	download	more...
Ruby 2.1.5	2014-11-13	download	more...
Ruby 2.0.0-p598	2014-11-13	download	more...
Ruby 1.9.3-p551	2014-11-13	download	more...
Ruby 2.1.4	2014-10-27	download	more...
Ruby 2.0.0-p594	2014-10-27	download	more...
Ruby 1.9.3-p550	2014-10-27	download	more...
Ruby 2.1.3	2014-09-19	download	more...
Ruby 2.0.0-p576	2014-09-19	download	more...
Ruby 2.2.0-preview1	2014-09-18	download	more...
Ruby 1.9.2-p330	2014-08-19	download	more...
Ruby 1.9.3-p547	2014-05-16	download	more...
Ruby 2.1.2	2014-05-09	download	more...
Ruby 2.0.0-p481	2014-05-09	download	more...
Ruby 2.1.1	2014-02-24	download	more...
Ruby 2.0.0-p451	2014-02-24	download	more...
Ruby 1.9.3-p545	2014-02-24	download	more...
Ruby 2.1.0	2013-12-25	download	more...
Ruby 2.1.0-rc1	2013-12-20	download	more...
Ruby 2.1.0-preview2	2013-11-22	download	more...
Ruby 2.0.0-p353	2013-11-22	download	more...
Ruby 1.9.3-p484	2013-11-22	download	more...
Ruby 2.1.0-preview1	2013-09-23	download	more...
Ruby 2.0.0-p247	2013-06-27	download	more...
Ruby 1.9.3-p448	2013-06-27	download	more...
Ruby 1.8.7-p374	2013-06-27	download	more...
Ruby 2.0.0-p195	2013-05-14	download	more...
Ruby 1.9.3-p429	2013-05-14	download	more...
Ruby 2.0.0	2013-02-24	download	more...
Ruby 1.9.3-p392	2013-02-22	download	more...
Ruby 2.0.0-rc2	2013-02-08	download	more...
Ruby 1.9.3-p385	2013-02-06	download	more...
Ruby 1.9.3-p374	2013-01-17	download	more...
Ruby 1.9.3-p362	2012-12-25	download	more...
Ruby 1.9.3-p327	2012-11-09	download	more...
Ruby 1.9.3-p286	2012-10-12	download	more...
Ruby 1.8.7-p370	2012-06-29	download	more...
Ruby 1.9.2-p320	2012-04-21	download	more...
Ruby 1.9.3-p194	2012-04-20	download	more...
Ruby 1.9.3-p125	2012-02-16	download	more...
Ruby 1.9.3	2011-10-31	download	more...
Ruby 1.9.3-rc1	2011-09-24	download	more...
Ruby 1.9.3-preview1	2011-08-01	download	more...
Ruby 1.9.2-p290	2011-07-15	download	more...
Ruby 1.8.7-p352	2011-07-02	download	more...
Ruby 1.9.2-p136	2010-12-25	download	more...
Ruby 1.8.7-p330	2010-12-25	download	more...
Ruby 1.9.2	2010-08-18	download	more...
Ruby 1.9.1-p430	2010-08-16	download	more...
Ruby 1.8.7-p302	2010-08-16	download	more...
Ruby 1.9.2-rc2	2010-07-11	download	more...
Ruby 1.9.2-rc1	2010-07-02	download	more...
Ruby 1.9.1-p429	2010-07-02	download	more...
Ruby 1.8.7-p299	2010-06-23	download	more...
Ruby 1.8.7-p248	2009-12-25	download	more...
Ruby 1.9.1-p376	2009-12-07	download	more...
Ruby 1.9.2-preview1	2009-07-20	download	more...
Ruby 1.9.1-p243	2009-07-20	download	more...
Ruby 1.9.1-p129	2009-05-12	download	more...
Ruby 1.8.7-p160	2009-04-18	download	more...
Ruby 1.8.6-p368	2009-04-18	download	more...
Ruby 1.9.1	2009-01-30	download	more...
Ruby 1.9.1-preview1	2008-10-28	download	more...
Ruby 1.8.7-p72	2008-08-11	download	more...
Ruby 1.8.6-p287	2008-08-11	download	more...
Ruby 1.8.7	2008-05-31	download	more...
Ruby 1.9.0	2007-12-25	download	more...
Ruby 1.8.6	2007-03-12	download	more...
Ruby 1.8.5	2006-08-29	download	more...
Ruby 1.8.4	2005-12-24	download	more...
Ruby 1.8.4-preview2	2005-12-14	download	more...
Ruby 1.8.3	2005-09-21	download	more...
Ruby 1.8.2	2004-12-26	download	more...
Ruby 1.8.2-preview4	2004-12-22	download	more...
Ruby 1.8.2-preview3	2004-11-08	download	more...
Ruby 1.8.2-preview2	2004-07-30	download	more...
Ruby 1.8.2-preview1	2004-07-21	download	more...
Ruby 1.8.0	2003-08-04	download	more...
Ruby 1.6.7	2002-03-01	download	more...

--- # Libraries Source: https://www.ruby-lang.org/en/libraries.md As with most programming languages, Ruby leverages a wide set of third-party libraries. {: .summary} Nearly all of these libraries are released in the form of a **gem**, a packaged library or application that can be installed with a tool called [**RubyGems**][1]. RubyGems is a Ruby packaging system designed to facilitate the creation, sharing and installation of libraries (in some ways, it is a distribution packaging system similar to, say, `apt-get`, but targeted at Ruby software). Ruby comes with RubyGems by default since version 1.9, previous Ruby versions require RubyGems to be [installed by hand][2]. Some other libraries are released as archived (.zip or .tar.gz) directories of **source code**. Installation processes may vary, typically a `README` or `INSTALL` file is available with instructions. Let’s take a look at finding libraries and installing them for your own use. ### Finding libraries The main place where libraries are hosted is [**RubyGems.org**][1], a public repository of gems that can be searched and installed onto your machine. You may browse and search for gems using the RubyGems website, or use the `gem` command. Using `gem search -r`, you can search RubyGems' repository. For instance, `gem search -r rails` will return a list of Rails-related gems. With the `--local` (`-l`) option, you would perform a local search through your installed gems. To install a gem, use `gem install [gem]`. Browsing installed gems is done with `gem list`. For more information about the `gem` command, see below or head to [RubyGems’ docs][3]. There are other sources of libraries though. [**GitHub**][5] is the main Ruby-related content repository. Most often a gem source code will be hosted on GitHub while being published as a fully-fledged gem to RubyGems.org. [**The Ruby Toolbox**][6] is a project that makes it easy to explore open source Ruby projects. It has categories for various common development tasks, collects a lot of information about the projects like release and commit activity or dependencies and rates projects based on their popularity on RubyGems.org and GitHub. This makes it easy to find a gem which solves a particular problem such as web frameworks, documentation tools and code quality libraries. ### A few more words about RubyGems Here is a quick review of the `gem` command for your daily use. [More detailed documentation][7] is available, covering all aspects of this packaging system. #### Searching among available gems The **search** command can be used to look for gems, based on a string. Gems which names start with the specified string will be listed in return. For instance, to search for the “html”-related gems:

$ gem search -r html

*** REMOTE GEMS ***

html-sample (1.0, 1.1)

The `--remote` / `-r` flag indicates that we want to inspect the official RubyGems.org repository (default behaviour). With the `--local` / `-l` flag you would perform a local search among your installed gems. #### Installing a gem Once you know which gem you would like to **install**, for instance the popular Ruby on Rails framework:

$ gem install rails

You can even install just a specific version of the library, using the `--version` / `-v` flag:

$ gem install rails --version 5.0

#### Listing all gems For a **list** of all locally installed gems:

$ gem list

To obtain a (very long) list of all gems available on RubyGems.org:

$ gem list -r

#### Help! Documentation is available inside your terminal:

$ gem help

For instance, `gem help commands` is very useful as it outputs a list of all `gem`’s commands. #### Crafting your own gems RubyGems.org has [several guides][3] about this topic. You may also want to investigate [Bundler][9], a generic tool which helps you manage an application’s dependencies and may be used along RubyGems. [1]: https://rubygems.org/ [2]: https://rubygems.org/pages/download/ [3]: http://guides.rubygems.org/ [5]: https://github.com/ [6]: https://www.ruby-toolbox.com/ [7]: http://guides.rubygems.org/command-reference/ [9]: http://bundler.io/ --- # Privacy Policy for ruby-lang.org Source: https://www.ruby-lang.org/en/privacy.md This privacy policy covers ruby-lang.org. ## Email We will not give away your email address to anyone, who is not related to the operations of ruby-lang.org. We will also never ask you to send us any of your passwords via email. ## Logfiles ruby-lang.org records access logs of the requests that reach the web servers, but we use those files only for debugging and statistical purposes. We use GitHub Pages for www.ruby-lang.org. Please refer [Usage limits of GitHub Pages](https://docs.github.com/en/pages/getting-started-with-github-pages/about-github-pages#data-collection). ## Cookies Some sites under ruby-lang.org (e.g. bugs.ruby-lang.org) uses cookies to keep track of user preferences. Unless you login on the site, the cookies will not be used to store personal information and we do not give away the information from the cookies. ## Acknowledgements This privacy policy is based on the [php.net privacy policy](https://www.php.net/privacy.php). --- # Security Source: https://www.ruby-lang.org/en/security.md Here you will find information about security issues of Ruby. {: .summary} ## Reporting Security Vulnerabilities Security vulnerabilities in the Ruby programming language should be reported through our [HackerOne program page](https://hackerone.com/ruby) or via email to security@ruby-lang.org ([the PGP public key](/security.asc)), which is a private mailing list. Please ensure you read the specific details around the scope of our program before reporting an issue. Any valid reported problems will be published after fixes. If you have found an issue affecting one of our websites, please report it [via GitHub](https://github.com/ruby/www.ruby-lang.org/issues/new). If you have found an issue that affects a specific Ruby community’s gem, follow the [instructions on RubyGems.org](http://guides.rubygems.org/security/#reporting-security-vulnerabilities). ## Security Mailing List The members of the security@ruby-lang.org mailing list are people who provide Ruby (Ruby committers and authors of other Ruby implementations, distributors, PaaS platformers). The members must be individual people, mailing lists are not permitted. If you represent one of these organizations, please contact us to join the list. ## Known issues Here are recent issues:

Security advisories: CVE-2026-80212 and CVE-2026-80213
2026-08-27
CVE-2026-46727: Use-after-free in pthread-based getaddrinfo timeout handler
2026-05-20
CVE-2026-41316: ERB @_init deserialization guard bypass via def_module / def_method / def_class
2026-04-21
CVE-2026-27820: Buffer overflow vulnerability in Zlib::GzipReader
2026-03-05
CVE-2025-61594: URI Credential Leakage Bypass previous fixes
2025-10-07
CVE-2025-58767: DoS vulnerability in REXML
2025-09-18
CVE-2025-24294: Possible Denial of Service in resolv gem
2025-07-08
CVE-2025-43857: DoS vulnerability in net-imap
2025-04-28
Security advisories: CVE-2025-27219, CVE-2025-27220 and CVE-2025-27221
2025-02-26
CVE-2025-25186: DoS vulnerability in net-imap
2025-02-10
CVE-2024-49761: ReDoS vulnerability in REXML
2024-10-28
CVE-2024-43398: DoS vulnerability in REXML
2024-08-22
CVE-2024-41946: DoS vulnerability in REXML
2024-08-01
CVE-2024-41123: DoS vulnerabilities in REXML
2024-08-01
CVE-2024-39908: DoS vulnerability in REXML
2024-07-16
CVE-2024-35176: DoS vulnerability in REXML
2024-05-16
CVE-2024-27282: Arbitrary memory address read vulnerability with Regex search
2024-04-23
CVE-2024-27281: RCE vulnerability with .rdoc_options in RDoc
2024-03-21
CVE-2024-27280: Buffer overread vulnerability in StringIO
2024-03-21
CVE-2023-36617: ReDoS vulnerability in URI
2023-06-29
CVE-2023-28756: ReDoS vulnerability in Time
2023-03-30
CVE-2023-28755: ReDoS vulnerability in URI
2023-03-28
CVE-2021-33621: HTTP response splitting in CGI
2022-11-22
CVE-2022-28738: Double free in Regexp compilation
2022-04-12
CVE-2022-28739: Buffer overrun in String-to-Float conversion
2022-04-12
CVE-2021-41819: Cookie Prefix Spoofing in CGI::Cookie.parse
2021-11-24
CVE-2021-41816: Buffer Overrun in CGI.escape_html
2021-11-24
CVE-2021-41817: Regular Expression Denial of Service Vulnerability of Date Parsing Methods
2021-11-15
CVE-2021-31810: Trusting FTP PASV responses vulnerability in Net::FTP
2021-07-07
CVE-2021-32066: A StartTLS stripping vulnerability in Net::IMAP
2021-07-07
CVE-2021-31799: A command injection vulnerability in RDoc
2021-05-02
CVE-2021-28965: XML round-trip vulnerability in REXML
2021-04-05
CVE-2021-28966: Path traversal in Tempfile on Windows
2021-04-05
CVE-2020-25613: Potential HTTP Request Smuggling Vulnerability in WEBrick
2020-09-29
CVE-2020-10933: Heap exposure vulnerability in the socket library
2020-03-31
CVE-2020-10663: Unsafe Object Creation Vulnerability in JSON (Additional fix)
2020-03-19
CVE-2019-16201: Regular Expression Denial of Service vulnerability of WEBrick's Digest access authentication
2019-10-01
CVE-2019-15845: A NUL injection vulnerability of File.fnmatch and File.fnmatch?
2019-10-01
CVE-2019-16254: HTTP response splitting in WEBrick (Additional fix)
2019-10-01
CVE-2019-16255: A code injection vulnerability of Shell#[] and Shell#test
2019-10-01
Multiple jQuery vulnerabilities in RDoc
2019-08-28
Multiple vulnerabilities in RubyGems
2019-03-05
CVE-2018-16395: OpenSSL::X509::Name equality check does not work correctly
2018-10-17
CVE-2018-16396: Tainted flags are not propagated in Array#pack and String#unpack with some directives
2018-10-17
CVE-2018-6914: Unintentional file and directory creation with directory traversal in tempfile and tmpdir
2018-03-28
CVE-2018-8779: Unintentional socket creation by poisoned NUL byte in UNIXServer and UNIXSocket
2018-03-28
CVE-2018-8780: Unintentional directory traversal by poisoned NUL byte in Dir
2018-03-28
CVE-2018-8777: DoS by large request in WEBrick
2018-03-28
CVE-2017-17742: HTTP response splitting in WEBrick
2018-03-28
CVE-2018-8778: Buffer under-read in String#unpack
2018-03-28
Multiple vulnerabilities in RubyGems
2018-02-17
CVE-2017-17405: Command injection vulnerability in Net::FTP
2017-12-14
CVE-2017-10784: Escape sequence injection vulnerability in the Basic authentication of WEBrick
2017-09-14
CVE-2017-0898: Buffer underrun vulnerability in Kernel.sprintf
2017-09-14
CVE-2017-14033: Buffer underrun vulnerability in OpenSSL ASN1 decode
2017-09-14
CVE-2017-14064: Heap exposure vulnerability in generating JSON
2017-09-14
Multiple vulnerabilities in RubyGems
2017-08-29
CVE-2015-7551: Unsafe tainted string usage in Fiddle and DL
2015-12-16
CVE-2015-1855: Ruby OpenSSL Hostname Verification
2015-04-13
CVE-2014-8090: Another Denial of Service XML Expansion
2014-11-13
CVE-2014-8080: Denial of Service XML Expansion
2014-10-27
Changed default settings of ext/openssl
2014-10-27
Dispute of Vulnerability CVE-2014-2734
2014-05-09
OpenSSL Severe Vulnerability in TLS Heartbeat Extension (CVE-2014-0160)
2014-04-10
Heap Overflow in YAML URI Escape Parsing (CVE-2014-2525)
2014-03-29
Heap Overflow in Floating Point Parsing (CVE-2013-4164)
2013-11-22
Hostname check bypassing vulnerability in SSL client (CVE-2013-4073)
2013-06-27
Object taint bypassing in DL and Fiddle in Ruby (CVE-2013-2065)
2013-05-14

More known issues: * [Entity expansion DoS vulnerability in REXML (XML bomb, CVE-2013-1821)][1] published at 22 Feb, 2013. * [Denial of Service and Unsafe Object Creation Vulnerability in JSON (CVE-2013-0269)][2] published at 22 Feb, 2013. * [XSS exploit of RDoc documentation generated by rdoc (CVE-2013-0256)][3] published at 6 Feb, 2013. * [Hash-flooding DoS vulnerability for ruby 1.9 (CVE-2012-5371)][4] published at 10 Nov, 2012. * [Unintentional file creation caused by inserting a illegal NUL character (CVE-2012-4522)][5] published at 12 Oct, 2012. * [$SAFE escaping vulnerability about Exception#to\_s / NameError#to\_s (CVE-2012-4464, CVE-2012-4466)][6] published at 12 Oct, 2012. * [Security Fix for RubyGems: SSL server verification failure for remote repository][7] published at 20 Apr, 2012. * [Security Fix for Ruby OpenSSL module: Allow 0/n splitting as a prevention for the TLS BEAST attack][8] published at 16 Feb, 2012. * [Denial of service attack was found for Ruby\'s Hash algorithm (CVE-2011-4815)][9] published at 28 Dec, 2011. * [Exception methods can bypass $SAFE][10] published at 18 Feb, 2011. * [FileUtils is vulnerable to symlink race attacks][11] published at 18 Feb, 2011. * [XSS in WEBrick (CVE-2010-0541)][12] published at 16 Aug, 2010. * [Buffer over-run in ARGF.inplace\_mode=][13] published at 2 Jul, 2010. * [WEBrick has an Escape Sequence Injection vulnerability (CVE-2009-4492)][14] published at 10 Jan, 2010. * [Heap overflow in String (CVE-2009-4124)][15] published at 7 Dec, 2009. * [DoS vulnerability in BigDecimal](/en/news/2009/06/09/dos-vulnerability-in-bigdecimal/ (CVE-2009-1904)) published at 9 Jun, 2009. * [DoS vulnerability (CVE-2008-3790) in REXML](/en/news/2008/08/23/dos-vulnerability-in-rexml/) published at 23 Aug, 2008. * [Multiple vulnerabilities in Ruby](/en/news/2008/08/08/multiple-vulnerabilities-in-ruby/) published at 8 Aug, 2008. * [Arbitrary code execution vulnerabilities](/en/news/2008/06/20/arbitrary-code-execution-vulnerabilities/) published at 20 Jun, 2008. * [File access vulnerability of WEBrick](/en/news/2008/03/03/webrick-file-access-vulnerability/) published at 3 Mar, 2008. * [Net::HTTPS Vulnerability](/en/news/2007/10/04/net-https-vulnerability/) published at 4 Oct, 2007. * [Another DoS Vulnerability in CGI Library](/en/news/2006/12/04/another-dos-vulnerability-in-cgi-library/) published at 4 Dec, 2006. * [DoS Vulnerability in CGI Library (CVE-2006-5467)](/en/news/2006/11/03/CVE-2006-5467/) published at 3 Nov, 2006. * [Ruby vulnerability in the safe level settings](/en/news/2005/10/03/ruby-vulnerability-in-the-safe-level-settings/) published at 2 Oct, 2005. [1]: /en/news/2013/02/22/rexml-dos-2013-02-22/ [2]: /en/news/2013/02/22/json-dos-cve-2013-0269/ [3]: /en/news/2013/02/06/rdoc-xss-cve-2013-0256/ [4]: /en/news/2012/11/09/ruby19-hashdos-cve-2012-5371/ [5]: /en/news/2012/10/12/poisoned-NUL-byte-vulnerability/ [6]: /en/news/2012/10/12/cve-2012-4464-cve-2012-4466/ [7]: /en/news/2012/04/20/ruby-1-9-3-p194-is-released/ [8]: /en/news/2012/02/16/security-fix-for-ruby-openssl-module/ [9]: /en/news/2011/12/28/denial-of-service-attack-was-found-for-rubys-hash-algorithm-cve-2011-4815/ [10]: /en/news/2011/02/18/exception-methods-can-bypass-safe/ [11]: /en/news/2011/02/18/fileutils-is-vulnerable-to-symlink-race-attacks/ [12]: /en/news/2010/08/16/xss-in-webrick-cve-2010-0541/ [13]: /en/news/2010/07/02/ruby-1-9-1-p429-is-released/ [14]: /en/news/2010/01/10/webrick-escape-sequence-injection/ [15]: /en/news/2009/12/07/heap-overflow-in-string/

Ruby Association (hosting)
Ruby no Kai (build server)
AWS (hosting)
Heroku (hosting)
IBM (hosting)
Fastly (CDN)
Hatena (Mackerel, server monitoring)
Datadog (server monitoring)
1Password (password manager)