To create a inherited class
class sibling < superclass

And the sibling class can then call any methods etc within the superclass. The code example explains in code

# base "Books" class
class Books
   # this is called within the .new class call
   def initialize(name, author, year)
       @name = name;
       @author = author;
       @year = year;
   end
 
   def to_s
          # return the to_s (to_string)
          "Books - Name #{@name} - Author #{@author} - Year #{@year}"
   end          
end
 
# this class is Inherited from the "Books" class
class BookToCD < Books
    def initialize(name, author, year, cdID)
           # use the "Books" class initlialize to setup the local variables within the super/inherited class
           super(name, author, year)
           #setup the local variables
           @cdID = cdID
    end
 
    def to_s
           # get the result from the super class
           result = super.to_s
           # return the result from the super class + the local cdID variable
           return result + " - CDID #{@cdID}" 
    end
end
# create a book
book = Books.new("Programming in Ruby", "Ruby Team", 2006)
# inspect outputs the internel structure of the class
puts book.inspect
puts book.to_s
 
booktocd = BookToCD.new("CD read of programming in Ruby", "Ruby Team",2006, 1)
# the inspect shows that the new class has a different memory address
puts booktocd.inspect
puts booktocd.to_s

Once executed on the command line the result is

#<Books:0x2777070 @year=2006, @name="Programming in Ruby", @author="Ruby Team">
Books - Name Programming in Ruby - Author Ruby Team - Year 2006
#<BookToCD:0x2776f38 @year=2006, @name="CD read of programming in Ruby", @cdID=1, @author="Ruby Team">
Books - Name CD read of programming in Ruby - Author Ruby Team - Year 2006 - CDID 1

As you can see the inspect method is showing that the memory block of the book and also booktocd are not the same even though they are sharing the same internals, this is Object Orientated.

The manor in which Ruby returns values from a method is either by the return keyword or by the last executed line of code, thus if the result for the return of the method is the last line then there is no need to use the return keyword, but of course if the returnable value is calculated within the middle of the method and the rest is to clean up the method then use the return keyword.

# this is a basic method
def saySomething(name)
       result = "hi there #{name}"
       return result
end
 
# but Ruby will return the last evaluated line, thus this method
# is the same as the above one.
def saySomething2(name)
       "hi there #{name}"
end
 
# the two methods that are the same in there results
puts saySomething("Ian")
puts saySomething2("Ian Porter")

Below is how Ruby uses the array structure and also the hash structure, an array is defined within the [ ] brackets and the start of the array is 0, but within a hash since there is no start to the hash keys, then there is an hash key and then the values associated with that key. The hash structure is defined within { } brackets.

# this is a array
a = ['Gentoo Linux','is','great']
 
#this is a hash, an hash is a key -> value
has = { 'Gentoo' => 'Gentoo Linux',
       'RH' => 'Red Hat Linux'}       # hash
 
puts a[0]       # print the first element of the array
puts a              # print the arary
 
puts "The Key value of RH within the hash"
puts has['RH']       # print the value assoicated with the key RH
puts "The hash in full"
puts has

Once executed from the console, the output is

hi there Ian
hi there Ian Porter

for the first method demonstrating that the result value is the same

Gentoo Linux
Gentoo Linux
is
great
The Key value of RH within the hash
Red Hat Linux
The hash in full
RHRed Hat LinuxGentooGentoo Linux

Which shows the results of the program, this shows that the two methods return in the same manor and also an array is broken into separate blocks, but a hash has a continuous memory block in nature.

module SillyModule # module is a single instance object, e.g. they can have methods and constants
  def hello
    "Hello."
  end
end
 
class SillyClass	# a class can include a module and expand on it, an class can generate many instances (objects) of itself.
 
  include SillyModule # also use the sillymodule as well.
    def bob
      "timing is everything."
  end
 
end
s = SillyClass.new
puts s.hello  # Hello.
puts s.class # SillyClass - displays the class name
puts s.bob # timing is everything

Save this code as class_module.rb, it will create a module that is included within the SillyClass. To demonstrate that the module is a single instance of a object, if you try to create a new object, e.g. mod = SillyModule.new, the compile will class.rb:20: undefined method `new’ for SillyModule:Module (NoMethodError) since the new method is not part of a module but only a class.

The source code

# define a function called addtwo with two parameters
def addtwo(a, b) 
       a + b; # return a + b
end
 
print "Please enter number 1 : ";
# get the input from the console, 
val1 = gets;
print "Please enter number 2 : ";
val2 = gets;
# convert the string console inputs to_i (to_integers) and add together
print "Answer : " , (val1.to_i + val2.to_i), "\n";

save as addtwonumbers_function.rb, this program will function the same as the previous tutorial apart from the inner working will call the method. The method programming allows for one method to be called multiple times, e.g. Within the example above there could be a method that was 5 lines in length and instead of writing the same 5 lines each time, you just write a method that is called.

The gets function is able to get a string from the console input, with the string inputted this allows the string function .to_i (to_integer) conversion for the answer to add up to integer values.

The code

print "Please enter number 1 : ";
# get the input from the console, 
val1 = gets;
print "Please enter number 2 : ";
val2 = gets;
# convert the string console inputs to_i (to_integers) and add together
print "Answer : " , (val1.to_i + val2.to_i), "\n";

save that as addtwonumbers.rb.

To run ruby addtwonumbers.rb, and the output would be similar to

Please enter value 1 : 30
Please enter value 2: 23
Answer = 53

The objects e.g. File, have different functions associated with them. The File.new creates a new file, the IO (InputOutput) object is an allows for different Input output tasks, which in this case to read each line of the input file (countrys.txt) and assign the value to ‘line’. The puts prints out what has been read in, and the syswrite, which was created from the File.net outputs to the output file.

NOTE: the { } are the begin and end of a code structure, e.g. While begin; do something; end;

This is the code

OutFile = File.new("sqlrubycountry.txt","w");
 
IO.foreach("countrys.txt") { |line|
        puts line
        OutFile.syswrite("insert into country(place) values (\"#{line.strip}\");\n");
}
 
OutFile.close;

if you save that as rubyreadfile.rb and also create a countrys.txt file with what ever text you like, e.g.
United Kingdom
France
Germany
United States etc.

The output of the program (ruby rubyreadfile.rb) will display each line that is read from the input file and the output file will have some other text in it, for demonstrating purposes, have done some sql code.