Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:56:08Z

Mssurani: /* Conclusion */

'''"Lecture 6"'''
='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

* You can separate object characteristics into nonoverlapping sets.
* Lets you create complex classes using only the characteristics that you need, without a proliferation of base classes.

===Disadvantages===

* Complicates method dispatch and impose additional requirements on an application.
* It is essential to be aware of dependencies on subclass-superclass ordering, particularly in method selection and slot initialization.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

The above wiki-chapter covers all the topics which were introduced as part of Lecture 6. We began by discussing the topic of Regular Expressions and how ruby uses them. We then drifted our interests towards one of the main topics in Ruby: Modules and Mixins. We discussed the implementation details of modules and showed how modules can be mixed in a class and what advantages it provides.

Finally , we introduced the concept of Multiple Inheritance and its advantages and disadvantages. We also discussed how mixins avoid the diamond problem caused by Multiple inheritance.

We then conclude with the topic of extending objects: how and why is it done.

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:50:32Z

Mssurani:

'''"Lecture 6"'''
='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

* You can separate object characteristics into nonoverlapping sets.
* Lets you create complex classes using only the characteristics that you need, without a proliferation of base classes.

===Disadvantages===

* Complicates method dispatch and impose additional requirements on an application.
* It is essential to be aware of dependencies on subclass-superclass ordering, particularly in method selection and slot initialization.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:50:15Z

Mssurani:

'''" Lecture 6"'''
='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

* You can separate object characteristics into nonoverlapping sets.
* Lets you create complex classes using only the characteristics that you need, without a proliferation of base classes.

===Disadvantages===

* Complicates method dispatch and impose additional requirements on an application.
* It is essential to be aware of dependencies on subclass-superclass ordering, particularly in method selection and slot initialization.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:46:41Z

Mssurani: /* Disadvantages */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

* You can separate object characteristics into nonoverlapping sets.
* Lets you create complex classes using only the characteristics that you need, without a proliferation of base classes.

===Disadvantages===

* Complicates method dispatch and impose additional requirements on an application.
* It is essential to be aware of dependencies on subclass-superclass ordering, particularly in method selection and slot initialization.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:44:03Z

Mssurani: /* Advantages */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

* You can separate object characteristics into nonoverlapping sets.
* Lets you create complex classes using only the characteristics that you need, without a proliferation of base classes.

===Disadvantages===

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:41:52Z

Mssurani: /* Multiple Inheritance */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

===Advantages===

===Disadvantages===

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:40:47Z

Mssurani: /* Mixins */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

='''Mixins'''=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:40:31Z

Mssurani: /* Modules */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

='''Modules'''=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:39:31Z

Mssurani: /* Comparable and Enumerable */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

='''Comparable and Enumerable'''=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:38:32Z

Mssurani: /* Character Classes */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

The following line will change the first occurrence of any character in the range from a-y in the given string with z

"now is the time".sub(/[a-y]/, "z")
=> "zow is the time"

The following line will change the all occurrences of any character in the range from a-y in the given string with z

"now is the time".gsub(/[a-y]/, "z")
=> "zzz zz zzz zzzz"
The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:35:02Z

Mssurani: /* Repetition */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
So far we have seen how to match single characters. We can use repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

The following line replaces one or more occurrences of 'o' in choose by 'e'

"choose".sub(/o+/, "e")
=> "chese"

The following line replaces zero or more occurrences of 'o' in choose by 'e'

"choose".sub(/o?/, "e")
=> "echoose"

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:30:00Z

Mssurani: /* Regular Expressions */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html Regex Modifiers]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:29:14Z

Mssurani: /* Character Classes */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

The following table explains the the different types of character classes:<ref name="characterclass">[http://doc.infosnel.nl/ruby_regular_expressions.html Character Classes]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:28:09Z

Mssurani: /* Regular Expressions */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Regular_expression Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

The following table explains the the different types of character classes:<ref name="rubyregex">[http://doc.infosnel.nl/ruby_regular_expressions.html]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-21T02:14:24Z

Mssurani: /* Regular Expressions */

='''Regular Expressions'''=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Object-oriented_programming Definition of Regular Expression]</ref> Regular expressions are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. Regular expression processor is a program that interprets a regular expression written in a formal language. It either serves as a parser generator or examines text and identifies parts that match the provided specification.

We can demonstrate the power of regex with the help following list of some specifications that can be expressed using regular expressions:
*the sequence of characters "far" appearing consecutively in any context, such as in "far", "farmer", or "defarge"
*the sequence of characters "far" occurring in that order with other characters between them, such as in "filmstar"
*the word "far" when it appears as an isolated word
*the word "far" when preceded by the word "very" or "little"
*the word "far" when not preceded by the word "went"

Ruby, built as a better [http://en.wikipedia.org/wiki/Perl Perl] supports regular expressions as a language feature and its syntax is borrowed from Perl. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options.<ref name="rubyregex">[http://www.regular-expressions.info/ruby.html]</ref> The "modifiers" part is optional.

Ruby supports the following modifiers:

{| class="wikitable" border="1"
|-
! Modifier
! Description
|-
| /i
| makes the regex match case insensitive
|-
| /m
| makes the dot match newlines
|-
| /x
| tells Ruby to ignore whitespace between regex tokens
|-
| /o
| causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.
|-
|}

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 3/4 is written as /3\/4/ in Ruby.

==Search And Replace==

The sub() and gsub() methods of the String class can be used search and replace the first regex match or all regex matches respectively. To use sub and gsub we have to specify the regular expression we want to search for as the first parameter, and the replacement string as the second parameter.

The following statement replaces the first occurrence of 'c' in faculty with "".

faculty".sub(/c/, "")
=> "faulty"

The following statement replaces all occurrences of 'e' in cheese with 'o'

"cheese".gsub(/e/, "o")
=> "chooso"

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[dm]/ means d or m, as opposed to /dm/ which means d followed by m. The following examples uses character class.

/Pr[aeiou]gram/.match("Program") #=> #<MatchData "Program">

In a character class, we can use the hyphen (-). This is a metacharacter denoting an inclusive range of characters. [pqrs] is equivalent to [p-s]. A range can follow another range, so [abcdpqrs] is equivalent to [a-dp-s]. The order in which ranges or individual characters appear inside a character class is irrelevant.

"anecdote".sub(/[aeio]/, "u")
=>unecdote

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named. The following example depicts the use of carat.

"anecdote".sub(/[^aeio]/, "z")
=>azecdote

The following table explains the the different types of character classes:<ref name="rubyregex">[http://doc.infosnel.nl/ruby_regular_expressions.html]</ref>

{| class="wikitable" border="1" width = "80%" align = "center"
|-
! Class
! Match description
|-
| [0-9]
| Decimal digit character
|-
| [^0-9]
| Not a decimal digit character
|-
| [\s\t\r\n\f]
| Whitespace character
|-
| [^\s\t\r\n\f]
| Not a whitespace character
|-
| [A-Za-z0-9_]
| Word character (alpha, numeric, and underscore)
|-
| [^A-Za-z0-9_]
| Not a word character
|-
| [:alnum:]
| Alpha numeric ([A-Za-z0-9])
|-
| [:alpha:]
| Uppercase and lowercase letters ([A-Za-z])
|-
| [:blank:]
| Blank or tab character
|-
| [:space:]
| Whitespace characters
|-
| [:digit:]
| Decimal digit characters
|-
| [:lower:]
| Lowercase letters ([a-z])
|-
| [:upper:]
| Uppercase characters
|-
| [:print:]
| Any printable character, including space
|-
| [:graph:]
| Printable characters excluding space
|-
| [:punct:]
| Punctuation characters: any printable character excluding aplhanumeric or space
|-
| [:cntrl]
| Chontrol characters (0x00 to 0x1F and 0x7F)
|-
| [:xdigit:]
| Hexadecimal digits ([0-9a-fA-F])
|-
|}

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T21:44:58Z

Mssurani: /* Regular Expressions */

=Regular Expressions=
A [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a succinct and supple means for specifying and recognizing strings of text, such as particular characters, words, or patterns of characters.<ref name="defobject">[http://en.wikipedia.org/wiki/Object-oriented_programming Definition of Regular Expression]</ref> Regular expression are usually referred to by abbreviations like "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions. A program, regular expression processor interprets a regular expression written in a formal language. This either serves as a parser generator or examines text and identifies parts that match the provided specification.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T21:29:37Z

Mssurani:

=Regular Expressions=
In computing, a [http://en.wikipedia.org/wiki/Regular_expression regular expression] provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T21:08:48Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a [http://en.wikipedia.org/wiki/Class-based_programming set-based language], using include augments a class definition, and hence adds functionality to all objects of a class. But, Ruby can also act as a [http://en.wikipedia.org/wiki/Prototype-based_programming prototype-based] language. The dynamic nature of Ruby can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T21:03:08Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a set-based language, using include augments a class definition, and hence adds functionality to all objects of a class. But, ruby can also act as a prototype-based language. The Ruby dynamic nature can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

The module TA has a method gets_paycheck which returns true. This class is for students who are TAs

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T21:02:15Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
Ruby can act as a set-based language, using include augments a class definition, and hence adds functionality to all objects of a class.
But, it can also act as a prototype-based language. The Ruby dynamic nature can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

The following example explains this concept
We define a class Student, this class is for all students.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def gets_paycheck?
false
end
end

We create 2 objects of this class, (mihir and deepak), the basic idea is that students are not paid and thus the function gets_paycheck returns false for both the objects.

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> false

The module TA has a method gets_paycheck which returns true. This class is for students who are TAs

Now, Deepak became a TA, so he should receive a paycheck. We do not want modify the class Student since not all students receive paychecks. Thus, we create a new module TA for students who are TAs. The method gets_paycheck of TA returns true. Also, Deepak will now extend the module TA.

module TA
attr_accessor :course
def gets_paycheck?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.gets_paycheck? #=> false
deepak.gets_paycheck? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T20:36:25Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

='''Extending Objects'''=
The Ruby dynamic nature can be truly harnessed in a dynamic execution environment. One of the most powerful features is ability to extend (provide additional features to) any object at runtime. This is particularly helpful if we don’t want to modify the object’s class (be it Object for example) but the object itself only.

class Student
attr_reader :name, :age
def initialize(name, age)
@name, @age, = name, age
end
def on_pay_roll?
false
end
end

mihir = Student.new('Mihir Surani', 22)
deepak = Student.new('Deepak Anand', 25)
mihir.on_pay_roll? #=> false
deepak.on_pay_roll? #=> false

module TA
attr_accessor :course
def on_pay_roll?
true
end
end

deepak.extend(TA)
deepak.course = "OOLS"
mihir.on_pay_roll? #=> false
deepak.on_pay_roll? #=> true

mihir.inspect #=> "#<Student:0x2401e90 @name=\"Mihir Surani\", @age=22>"
deepak.inspect #=> "#<Student:0x2c8b390 @name=\"Deepak Anand\", @age=25, @course=\"OOLS\">"

='''Conclusion'''=

='''References'''=
<references/>

='''See Also'''=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T19:24:06Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

==Search And Replace==

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.

==Character Classes==
A character class is delimited with square brackets ([, ]) and lists characters that may appear at that point in the match. /[ab]/ means a or b, as opposed to /ab/ which means a followed by.

/W[aeiou]rd/.match("Word") #=> #<MatchData "Word">

Within a character class the hyphen (-) is a metacharacter denoting an inclusive range of characters. [abcd] is equivalent to [a-d]. A range can be followed by another range, so [abcdwxyz] is equivalent to [a-dw-z]. The order in which ranges or individual characters appear inside a character class is irrelevant.

/[0-9a-f]/.match('9f') #=> #<MatchData "9">
/[9f]/.match('9f') #=> #<MatchData "9">

If the first character of a character class is a caret (^) the class is inverted: it matches any character except those named.

/[^a-eg-z]/.match('f') #=> #<MatchData "f">

A character class may contain another character class. By itself this isn’t useful because [a-z] describes the same set as [a-z0-9]. However, character classes also support the && operator which performs set intersection on its arguments. The two can be combined as follows:

/[a-w&&[^c-g]z]/ # ([a-w] AND ([^c-g] OR z))
This is equivalent to:
/[abh-w]/

==Repetition==
The constructs described so far match a single character. They can be followed by a repetition metacharacter to specify how many times they need to occur. Such metacharacters are called quantifiers.

* * - Zero or more times
* + - One or more times
* ? - Zero or one times (optional)
* {n} - Exactly n times
* {n,} - n or more times
* {,m} - m or less times
* {n,m} - At least n and at most m times

# At least one uppercase character ('H'), at least one lowercase
# character ('e'), two 'l' characters, then one 'o'
"Hello".match(/[[:upper:]]+[[:lower:]]+l{2}o/) #=> #<MatchData "Hello">

=Modules=

Modules provide a structure to accumulate classes, methods and constants into a single, separately defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that the functionality of the modules can be ''mixed-in'' to the classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way :
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children) whereas modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and hence, they are all visible to each other but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into the picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'', following which included modules are known as‘mixins’. When we mix the modules into a class , all the objects created from that class will be able to use the instance methods of the mixed-in module as if they were defined in the class.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Monday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

This module defines a constant called FIRST_DAY and initializes it to "Monday". It also defines two methods which print the appropriate statement.

In order to include this module into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Monday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Monday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >=. This is done by mixing the module into the class and defining the <=> method. Once this is done , it is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object and returns -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume that we have a square class.

class Square
attr_reader :side
def initialize(side)
@side = side
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
side*side
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(5)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

=Conclusion=

=References=
<references/>

=See Also=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch4 4c dm

2011-10-20T18:52:54Z

Mssurani:

=Regular Expressions=
In computing, a regular expression provides a concise and flexible means for "matching" (specifying and recognizing) strings of text, such as particular characters, words, or patterns of characters. Abbreviations for "regular expression" include "regex" and "regexp". The concept of regular expressions was first popularized by utilities provided by Unix distributions, in particular the editor ed and the filter grep.[citation needed] A regular expression is written in a formal language that can be interpreted by a regular expression processor, which is a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. Historically, the concept of regular expressions is associated with Kleene's formalism of regular sets, introduced in 1950s.

Here are examples of specifications that could be expressed in a regular expression:
*the sequence of characters "car" appearing consecutively in any context, such as in "car", "cartoon", or "bicarbonate"
*the sequence of characters "car" occurring in that order with other characters between them, such as in "Icelander" or "chandler"
*the word "car" when it appears as an isolated word
*the word "car" when preceded by the word "blue" or "red"
*the word "car" when not preceded by the word "motor"
*a dollar sign immediately followed by one or more digits, and then optionally a period and exactly two more digits (for example, "$100" or "$245.99").

Ruby supports regular expressions as a language feature. In Ruby, a regular expression is written in the form of /pattern/modifiers where "pattern" is the regular expression itself, and "modifiers" are a series of characters indicating various options. The "modifiers" part is optional. This syntax is borrowed from Perl.

Ruby supports the following modifiers:

*/i makes the regex match case insensitive.
*/m makes the dot match newlines. Ruby indeed uses /m, whereas Perl and many other programming languages use /s for "dot matches newlines".
*/x tells Ruby to ignore whitespace between regex tokens.
*/o causes any #{...} substitutions in a particular regex literal to be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object.

You can combine multiple modifiers by stringing them together as in /regex/is.

In Ruby, the caret and dollar always match before and after newlines. Ruby does not have a modifier to change this. Use \A and \Z to match at the start or the end of the string.

Since forward slashes delimit the regular expression, any forward slashes that appear in the regex need to be escaped. E.g. the regex 1/2 is written as /1\/2/ in Ruby.

===Search And Replace===

Use the sub() and gsub() methods of the String class to search-and-replace the first regex match, or all regex matches, respectively, in the string. Specify the regular expression you want to search for as the first parameter, and the replacement string as the second parameter, e.g.: result = subject.gsub(/before/, "after").

To re-insert the regex match, use \0 in the replacement string. You can use the contents of capturing groups in the replacement string with backreferences \1, \2, \3, etc. Note that numbers escaped with a backslash are treated as octal escapes in double-quoted strings. Octal escapes are processed at the language level, before the sub() function sees the parameter. To prevent this, you need to escape the backslashes in double-quoted strings. So to use the first backreference as the replacement string, either pass '\1' or "\\1". '\\1' also works.
=Modules=

Modules provide a structure to collect Ruby classes, methods, and constants into a single, separately named and defined unit. This is useful so that one can avoid clashes with existing classes, methods, and constants, and also so that you can add (mix in) the functionality of modules into your classes.
The definition of a module is very similar to a class. Also, modules and classes are closely related. The Module class is the immediate ancestor of the Class class. Just like a class, a module can contain constants, methods and classes.

In [http://en.wikipedia.org/wiki/Ruby_(programming_language)Ruby programming language] , a module is defined in the following way
module <module name>
statement1
statement2
...........
end

Consider for example ,a module called MyModule , which defines the happy and the sad times.

module MyModule
GOODMOOD = "happy"
BADMOOD = "sad"
def greet
return "I'm #{GOODMOOD}. How are you?"
end
def MyModule.greet
return "I'm #{BADMOOD}. How are you?"
end
end

The above represents a module MyModule with a constant GOODMOOD and an “instance method” greet.
In addition to instance methods a module may also have module methods. Just as [http://en.wikipedia.org/wiki/Method_(computer_programming)#Class_methods class methods] are prefixed with the name of the class, module methods are prefixed with the name of the module as shown above in MyModule.greet.

In spite of their similarities, there are two major features which classes possess but which modules do not: instances and inheritance. Classes can have [http://en.wikipedia.org/wiki/Instance_(computer_science) instances] (objects), [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclasses] (parents) and [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses subclasses] (children); modules can have none of these.
Inspite of inability of the modules to be initialized and inherited ,they provide a namespace and prevent name clashes and they implement the mixin facility.

===Modules as Namespaces===

Modules <ref>[http://rubylearning.com/satishtalim/modules_mixins.html Modules] </ref> can be considered as a named ‘wrapper’ around a set of methods, constants and classes. The various bits of code inside the module share the same [http://en.wikipedia.org/wiki/Namespace ‘namespace’] and so they are all visible to each other, but not visible to code outside the module.

Consider the example of the MyModule described above

We can access the module constants just as we would access class constants using the :: scope resolution operator like this:
puts(MyModule::GOODMOOD) #-> happy
puts(MyModule::BADMOOD) #-> sad

We can access module methods using dot notation – that is, specifying the module name followed by a period and the method name

For example
puts( MyModule.greet ) # -> I’m sad. How are you?

Since modules define a closed space, we cannot access the instance method “greet” from outside the module.
puts greet # -> NameError: undefined local variable or method `greet' for main:Object

In case of classes , we could have created instances of the class which would all have access to the instance methods of the class. However modules cannot be instantiated. This is where mixins come into picture.

=Mixins=

A mixin <ref>[http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ Mixins] </ref> is a class that is mixed with a module or a set of modules. In other words the implementation of the class and module are intertwined and combined. The real usage of a mixin is exploited when the code in the mixin starts to interact with code in the class that uses it.In order to mix the modules into the class we make use of the “'''include'''” method. As it is included, the instance methods in the modules can be used just as though it were a normal instance method within the current scope.

The process of including a module is also called ''‘mixing in’'' – which explains why included modules are often called ‘mixins’. When you mix modules into a class definition, any objects created from that class will be able to use the instance methods of the mixed-in module just as though they were defined in the class itself.

class MyClass
include MyModule
def sayHi
puts( greet )
end
end

Not only can the methods of this class access the greet method from MyModule, but so too can any objects created from the class:

ob = MyClass.new
ob.sayHi # -> I'm happy. How are you?
puts(ob.greet) # -> I'm happy. How are you?

=== Require / Load ===

As programs get bigger and bigger, the amount of reusable code also increases. It would best to break this code into separate files, so that these files can be shared across different programs.
Typically the code organizes these files as class or module libraries. In order to incorporate the reusable code into new programs Ruby provides two statements.
load "<filename.rb>”
require “<filename>”

The load method includes the named Ruby source file every time the method is executed, whereas require loads any given file only once <ref>[http://ionrails.com/2009/09/19/ruby_require-vs-load-vs-include-vs-extend/ Require / Load / Include]</ref>

Consider the following ruby module written in the file Week.rb.

module Week
FIRST_DAY = "Sunday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end

In order to include the module Week into a class in another file, we need to load the Week.rb file first and then include it in the class.

class Decade
require "Week"
include Week
no_of_yrs=10
def no_of_months
puts Week::FIRST_DAY
number=10*12
puts number
end
end
d1=Decade.new
puts Week::FIRST_DAY # -> Sunday
puts Week.weeks_in_month #-> You have four weeks in a month
puts Week.weeks_in_year # -> You have 52 weeks in a year
puts d1.no_of_months # -> Sunday 120

The important things to consider is:

'''include''' makes features available, but does not execute the code.

'''require''' loads and executes the code one time (like a C #include).

'''load''' loads and executes the code every time it is encountered.

However, in order to allow mixins we always need to use ''include''.

= Comparable and Enumerable=

==Comparable==

The Comparable is a built in mixin module that provides the neat ability to define one’s own comparison ‘operators’ such as <, <=, ==, >= by mixing the module into your class and defining the <=> method. It is then possible to specify the criteria for comparing some value from the current object with some other value. The <=> compares the receiver against another object, returning -1, 0, or +1 depending on whether the receiver is less than, equal to, or greater than the other object respectively.

Assume we have a square class.

class Square
attr_reader :x
def initialize(x)
@x = x
end
end

In order to compare the areas of two Squares , we first need to include the Comparable mixin.
class square
include Comparable
.
.
.
def area
x*x
end
def <=>(other)
self.area<=>other.area
end
end

The <=> function ([http://en.wikipedia.org/wiki/Spaceship_operator spaceship operator]) uses Comparable mixin to compare the area of two Squares. We can call the Comparable methods on Square objects.
s1 = Square.new(3)
s2 = Square.new(4)
if s1 < s2
puts "The area of Square 1 is smaller than Square 2" # -> This is the output printed.
else if s1 > s2
puts "The area of Square 1 is larger than Square 2"
else
puts "The area of Square 1 equals to Square 2"
end
end

==Composing modules==
[http://www.ruby-doc.org/core-1.9.2/Enumerable.html Enumerable] is a standard mixin, which can be included in any class. It is a built in mix-in module for enumeration which provides collection classes with several traversal and searching methods, and with the ability to sort.
The Enumerable method is already included in the Array class and provides arrays with a number of useful methods such as include? which returns true if a specific value is found in an array, min which returns the smallest value, max which returns the largest and collect which creates a new array made up of values returned from a block.

arr = [1,2,3,4,5]
y = arr.collect{ |i| i } #=> y = [1, 2, 3, 4]
z = arr.collect{ |i| i * i } #=> z = [1, 4, 9, 16, 25]
arr.include?( 3 ) #=> true
arr.include?( 6 ) #=> false
arr.min #=> 1
arr.max #=> 5

Another important method which is provided by the Enumerable module is the inject method. The inject method can be used to repeatedly apply an operation to adjacent elements in a collection.

Consider the example of summing the elements of an array.
[1, 2, 3, 4].inject { |result, element| result + element } # => 10

The inject method takes an argument and a block. The block will be executed once for each element contained in the object that inject was called on ([1,2,3,4] in our example). The argument passed to inject will be yielded as the first argument to the block, the first time it's executed. The second argument yielded to the block will be the first element of the object that we called inject on. If a default value is not passed in as an argument when the block executes for the first time, the first argument will be set to the first element of the enumerable and the second argument will be set to the second element of the enumerable.

Since there is no default value passed in as an argument, the first time the block executes the first argument (result from the example) will be set to the first element of the array (1 from the example) and the second argument (element from the example) will be set to the second element of the enumerable (2 from the example).

The block will need to be executed 3 times, since the first execution will yield both the first and the second element. The first time the block executes it will add the result, 1, to the element, 2, and return a value of 3. The second time the block executes the result will be 3 and the element will also be 3 giving a return value of 6. The third and the final time the block executes, the result will be 6 and the element will be 4 , giving a return value of 10 which is the output.

The inject method and the other methods as mentioned above can be directly applied to built in classes such as Arrays , Range , Hash etc which contains the Enumerable module.

It is also possible to be able to apply Enumerable methods to classes which do not descend from existing classes which implement those methods. This can be done by including the Enumerable module in the class and then writing an iterator method called “each” .
Consider a class Collection, which does not have the enumerable method in its ancestors.

class Collection
include Enumerable
def initialize( someItems )
@items = someItems
end
def each
@items.each{ |i|
yield( i ) }
end
end

The Enumerable module is included in the Collection class. We can hence initialize a Collection object with an array, which will be stored in the instance variable, @items. When we call one of the methods provided by the Enumerable module (such as min, max or collect), this will ‘''behind the scenes''’ call the each method in order to obtain each piece of data one at a time.

things = Collection.new(['x','yz','defgh','ij','klmno'])
puts( things.min ) #=> "defgh"
puts( things.max ) #=> "yz"
puts( things.collect{ |i| i.upcase } ) #=> ["X", "YZ", "DEFGH", "IJ", "KLMNO"]

==Multiple Inheritance==

[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming]languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass. Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

One of the ambiguities associated with multiple inheritance is the [http://en.wikipedia.org/wiki/Diamond_problem “diamond problem”]. Different languages have approach this problem in different ways.

[http://en.wikipedia.org/wiki/Java_(programming_language) Java] makes use of the concept of Interfaces <ref>[http://download.oracle.com/javase/tutorial/java/concepts/interface.html Interfaces] </ref>. Using interfaces, Java allows multiple inheritance of interfaces but implementation which consists of methods and variables maybe only singly inherited. This way , Java ensure that there is no confusion over which method to call of which instance variable to use.

[http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel] makes use of the renaming clause and ensures that the ancestor methods used in the descendants are explicitly specified. This allows the methods of the base class to be shared between all its descendants.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes <ref>[http://www.dotnetfunda.com/articles/article467-abstract-class--explained.aspx Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Horse and Bird, each of which contain the talk method defined in them. The Pegasus class includes these two modules and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Horse
def talk
puts "I can Neigh !!!!! "
end
end

module Bird
def talk
puts "I can Chirp !!!!!"
end
end

class Pegasus
include Horse
include Bird
def talk
puts "I am a whinnying horse who can fly and chirp ! "
end
end

Aviary = Pegasus.new
Aviary.talk

When the method talk is called on the Aviary object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Pegasus class is defined the latest and hence “''I am a whinnying horse who can fly and chirp !''” is printed. If there was no method defined in the class, method from the Bird is printed since it is next in the hierarchy specified by the include statements. This way Ruby prevents any naming conflicts by always executing the most recently defined method.

=Conclusion=

=References=
<references/>

=See Also=

1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
3. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
4. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011

2011-10-19T18:45:19Z

Mssurani:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[CSC/ECE 517 Fall 2011/ch4 4c dm]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch1 1e dm

2011-09-01T00:29:27Z

Mssurani: /* '''Introduction''' */

CSC/ECE 517 Fall 2011/ch1 1e dm
----
='''Introduction'''=
This wiki article describes the [http://en.wikipedia.org/wiki/Block_(programming) block structured] and [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented] languages by highlighting their advantages and limitations along with providing a comparison between them.

='''Block Structured Languages'''=
[http://en.wikipedia.org/wiki/Block_(programming) Block structured languages] are a class of high-level languages in which a program is made up of blocks. A [http://en.wikipedia.org/wiki/Block_(programming) block] is a section of code which can be grouped together. Blocks consist of one or more declarations and statements. A block structured programming language uses and permits the creation of blocks and may also include nested blocks as components. The major function of using blocks is to enable the groups of statements within the block to be treated as if they were a single statement.

[http://en.wikipedia.org/wiki/Block_(programming) Block structured programming] is related to [http://en.wikipedia.org/wiki/Structured_programming structured programming], which is a technique for organizing and coding computer programs in which a hierarchy of modules is used, each having a single entry and a single exit point, and in which control is passed downward through the structure without unconditional branches to higher levels of the structure. A structured program is decomposed into a hierarchy of [http://en.wikipedia.org/wiki/Process_(computing) processes]. A process in this context is a body of code, typically a function or subroutine, that takes some input and manipulates it to produce an output. A process may be composed of other, more specialized processes, i.e., it may be a function that calls other functions. Structured Programming uses three types of [http://en.wikipedia.org/wiki/Control_flow control flow]: sequential, test, and iteration.

Examples of block structured programming languages are [http://en.wikipedia.org/wiki/ALGOL ALGOL], [http://en.wikipedia.org/wiki/Fortran FORTAN], [http://en.wikipedia.org/wiki/Pascal_(programming_language) Pascal], [http://en.wikipedia.org/wiki/C_(programming_language) C], [http://en.wikipedia.org/wiki/Python_(programming_language) Python], [http://en.wikipedia.org/wiki/Lisp Lisp], [http://en.wikipedia.org/wiki/Ada_(programming_language) Ada], [http://en.wikipedia.org/wiki/PL_SQL PL/SQL].

==Characteristics==
*Takes on the [http://en.wikipedia.org/wiki/Top-down_design top-to-bottom approach].
*Based around [http://en.wikipedia.org/wiki/Data_structures data structures] and [http://en.wikipedia.org/wiki/Subroutines subroutines].
*Uses single entry and exit block.
*The names of variables and other objects such as procedures which are declared in outer blocks are visible inside other inner blocks, unless they are shadowed by an object of the same name.
*Splits the tasks into modular forms.

==Advantages==
*Splitting of tasks into blocks/modules makes the program simpler and easier to read with less lines and codes.
*Leave the solution coarse where the solution is not interesting.
*Can save an order of magnitude in memory.
*Can save an order of magnitude in run time.
*Numerical accuracy improves with more grid where gradients are strongest.
*Being block-structured allows Fortran to be used for array operations.
*Overhead involved in coarse-fine interactions can be [http://en.wikipedia.org/wiki/Amortized_analysis amortized] over larger array calculations.
*Numerical accuracy is improved if the coarse-fine interface is kept to a codimension smaller than the solution.

==Limitations==
*Communication patterns between levels can be complex.
*Algorithm complexity can be substantial.
*No [http://en.wikipedia.org/wiki/Abstraction_(computer_science) data abstraction] or [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) information hiding] supported.

='''Object Oriented Languages'''=
[http://en.wikipedia.org/wiki/Object-oriented_programming Object oriented programming] is an approach to programming in which each data item with the operations used on it is designated as an object; the routines used to operate on the data item are called methods; and objects are grouped in a hierarchy of classes, with each class inheriting characteristics from the class above it.

The four fundamentals of object oriented programming languages are [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism], [http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance], [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Encapsulation] and [http://en.wikipedia.org/wiki/Abstraction_(computer_science) Abstraction].

Examples of object oriented programming languages are C++, Java, Smalltalk, Ruby.

==Concepts==

[http://en.wikipedia.org/wiki/Object_(computer_science) Objects:]
This is the basic unit of object oriented programming. That is both data and function that operate on data are bundled as a unit called as object.

[http://en.wikipedia.org/wiki/Class_(computer_science) Classes:]
The concept of class is similar to the concept of structure in C. In other words classes are the data types on which objects are created. So while a class is created no memory is allocated only when an object is created memory gets allocated.

[http://en.wikipedia.org/wiki/Inheritance_(computer_science) Inheritance:]
As the name suggests Inheritance is the process of forming a new class from an existing class that is from the existing class called as base class, new class is formed called as derived class. This is a very important concept of object oriented programming since this feature helps to reduce the code size.

[http://en.wikipedia.org/wiki/Abstraction_(computer_science) Data Abstraction:]
By this feature of object oriented programming it is possible to represent the needed information in program without presenting the details. Also by the feature of data abstraction it is possible to create user defined data types and thus increase the power of programming language.

[http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) Data Encapsulation:]
Data Encapsulation is the process of combining data and functions into a single unit called class. By this method one cannot access the data directly. Data is accessible only through the functions present inside the class. Thus Data Encapsulation gave rise to the important concept of data hiding.

[http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming Polymorphism:]
The ability to use an operator or function in different ways in other words giving different meaning or functions to the operators or functions is called polymorphism. Poly refers many. That is a single function or an operator functioning in many ways different upon the usage is called polymorphism.

[http://en.wikipedia.org/wiki/Method_overloading Overloading:]
The concept of overloading is also a branch of polymorphism. When the exiting operator or function is made to operate on new data type it is said to be overloaded.

[http://en.wikipedia.org/wiki/Reusability Reusability:]
That is object oriented programming has the feature of allowing an existing class which is written and debugged to be used by other programmers and there by provides a great time saving and also code efficiency to the language. Also it is possible to a have the existing class and adds new features to the existing class as pet the programmer’s choice.

Thus the object oriented programming features helps the program ad there by users of the application to achieve increased performance, it saves time of developing the application, give optimized code for the application, helps in gaining secured applications and there by helps in easier maintenance.

==Advantages==
*Simplicity: software objects model real world objects, so the complexity is reduced and the program structure is very clear.
*Modularity: each object forms a separate entity whose internal workings are decoupled from other parts of the system. Hence helps to reduce large problems to smaller, more manageable problems.
*Modifiability: it is easy to make minor changes in the data representation or the procedures in an OO program. Changes inside a class do not affect any other part of a program, since the only public interface that the external world has to a class is through the use of methods. *Extensibility: adding new features or responding to changing operating environments can be solved by introducing a few new objects and modifying some existing ones.
*Maintainability: objects can be maintained separately, making locating and fixing problems easier.
*Re-usability: objects can be reused in different programs.

==Limitations==
*Over generalization
*Artificial class relations
*Unnecessary complications

='''Compare and Contrast'''=

='''Block Structure in Object Oriented Programming'''=

='''Conclusion'''=

='''See Also'''=

='''References'''=
# [https://commons.lbl.gov/display/~dtgraves@lbl.gov/Advantages+and+disadvantages+of+block-structured+AMR Advantages of block structured languages]
# [http://wiki.answers.com/Q/Advantages_and_disadvantages_of_an_object-oriented_language_in_organization Advantages of object oriented languages]
# [http://www.dba-oracle.com/t_object_oriented_approach.htm Advantages of object oriented languages]
# [http://pages.cs.wisc.edu/~fischer/cs538.s08/lectures/Lecture06.4up.pdf]

='''External Links'''=
# [http://www.youtube.com/watch?v=Dw49WkGukMs&feature=feedwll&list=WL Video for Structured Programming]