rails-knowledge

React Ecosystem

2018-02-16T09:21:00.002-08:00

Composition Model : Everything is a component. we create composition functions inoder to build UI with components.

Declarative: Reduce side effects, Minimize Mutability, More readable code and less bugs.

Unidirectional Data Flow: Sate > UI (You manage the state, UI will automatically update on its own)

Explicit Mutation: this.setState we are explicitly update the state.

Just JavaScript:

TypeError: (0 , _chai.expect)(...).toBe is not a function

2016-06-09T00:22:00.002-07:00

Error while running Mocha tests:

TypeError: (0 , _chai.expect)(...).toBe is not a function

By doing some research, came to see that I need to use a different syntax while using 'chai'

By changing my test cases as below got worked.

expect(true).to.be.true;
expect(false).to.be.false;

Thank You,
Uma Mahesh.

jsdom

2016-06-08T07:50:00.003-07:00

A JavaScript implementation of the DOM and HTML standards

Install:

$ npm install jsdom

Its much more like DOM

its mainly used for testing

Its creates a virtual DOM.. there is no browser and no selenium scripts...

Thank You,
Uma Mahesh.

get latest code and rebase to local branch

2016-06-08T00:01:00.001-07:00

> git branch

> git checkout develop

To fetch all remote branches.
> git fetch origin

To rebase local develop branch with remote develop branch.
> git rebase origin/develop

> git checkout <your branch>

to rebase local branch with develop branch
> git rebase develop

Thank You,
Uma Mahesh.

command to delete remote branch from git

2016-06-07T23:17:00.001-07:00

Here is the command to delete branch from remote repo in git

> git push origin --delete <Branch name>

This will delete branch from local machine as well as remote repo.

Thank You,
Uma Mahesh.

Git push asking for username and password

2016-02-15T03:34:00.001-08:00

When I try to push the code to github, I need to submit username and password every time. I keep on asking for username and password while pushing the code.

I came to see its due to ssh.

I have checked my remote config of my git repo and came to see it was with https

>   git remote –v
Now I removed the remote repo which is with https as below
>   git remote rm origin

Now I added the remote repo with git as below
>   git remote add origin git@github.com:umamahesh/sampleapp.git

Now authentication happens without ssh and with keys. You can push the code without username and password.

Thank You,
Uma Mahesh.

get code from remote branch in git

2016-02-15T03:20:00.000-08:00

When you want to pull the branch code from same repo, first navigate to main branch. Main branch is the reference branch.

>   git checkout master

From the main branch checkout to ‘develop’ branch. Develop branch is the name of the remote branch I am referring to.
>   git checkout develop
>   git pull origin develop
Now you will get the latest code from develop branch.

Below are the steps to merge the code from your branch to develop branch.

Let’s suppose you are working on the branch ‘uma-development’, Now you want to merge your code to ‘develop’ branch.

>   git checkout uma-development
>   git rebase develop

you may see many conflicts while doing the rebase. Try to solve conflicts one by one… after solving the conflicts, do git add
>   git add.
>   git rebase –continue

once your conflicts got resolved you are done with rebase. Now your branch ‘uma-development ‘ is up to date with develop branch code.

Now push the code to develop branch in remote and then raise pull request to develop branch.

Thanks,
Uma Mahesh.

assign default layout in controller

2014-11-05T22:26:00.004-08:00

Here is the method to check layout in the controller.

You can debug the controller self object and check there is any layout name like this..

self.action_has_layout?

before_filter :check_and_assign_default_layout
def check_and_assign_default_layout
    unless self.action_has_layout?
      self.action_has_layout = "my_layout"
    end
end

Thank You,
Uma Mahesh.

Ruby on Rails Interview Questions

2014-10-24T02:54:00.002-07:00

Ruby Interview Questions

Ruby Interview Questions

1. What is a class method and how you will define it?
Class methods are methods that are called on a class without creating instance of that class.

# Way 1 # Way 2 #Way3
class Foo class Foo class Foo; end
def self.bar class << self def Foo.bar
puts 'class method' def bar puts 'class method'
end puts 'class method' end
end end end end

Calling class method => Foo.bar

2. What is an instance method and how you will instantiate it?

Instance methods are methods that are called on an instance of a class.

# Way 1 # Way 2 # Way 3
class Foo class Foo class Foo; end
def baz attr_accessor :baz foo = Foo.new
puts 'instance method' end def foo.bar
end foo = Foo.new puts 'instance method'
end foo.baz = 'instance method' end

Instantiating instance methods:

a). f = Foo.new
f.bar

b). g = Foo.new

g.send(:bar)

c). Foo.new.bar

3. What is singleton class and singleton method ? (http://www.devalot.com/articles/2008/09/ruby-singleton)

A singleton method is a method that is defined only for a single object.

o = "message" # A string is an object
def o.printme # Define a singleton method for this object
puts self
end
o.printme # Invoke the singleton

A method added to a single object rather than to a class of objects is known as a singleton method.
The implicit class object to which such singleton methods are added is sometimes called a singleton class or singel class instead.

4. What are the closures in ruby?

In Ruby, procs and lambdas are closures . Closure refers to an object that is both an invocable function and a variable binding for that function.

When you create a proc or a lambda, the resulting Proc object holds not just the executable block but also bindings for all the variables used by the block.

5. What is the difference between Proc and Lambda?

http://railsknowledge.blogspot.in/2014/10/what-is-difference-between-proc-and.html

6. What is the difference between Ruby 1.8.7 and 1.9.2?

http://railsknowledge.blogspot.in/2014/10/what-is-difference-between-ruby-187-and.html

7. What is a module and what is the use of it?

Like a class, a module is a named group of methods, constants, and class variables.
Modules are defined much like classes are, but the module keyword is used in place of
the class keyword. Unlike a class, however, a module cannot be instantiated, and it cannot be subclassed. Modules stand alone; there is no “module hierarchy” of inheritance. Modules are used as namespaces and as mixins.
Namespaces:
Modules are a good way to group related methods when object-oriented programming
is not necessary.

Mixins:
The second use of modules mixins. If a module defines instance methods instead of the class methods, those instance methods can be mixed in to other classes.

8. What is the difference between collect,select, reject and inject in ruby?

http://railsknowledge.blogspot.in/2014/10/what-is-difference-between.html

9. What is Enumerator in ruby?

An enumerator is an Enumerable object whose purpose is to enumerate some other object. To use enumerators in Ruby 1.8, you must require 'enumerator' . In Ruby 1.9, enumerators are built-in and no require is necessary.

10.Difference between ‘load’ and ‘require’ in Ruby?

The difference between load and require is that load includes the specified Ruby file every time the method is executed and require includes the Ruby file only once.

• In addition to loading source code, require can also load binary extensions to Ruby. Binary extensions are, of course, implementation-dependent, but in C-based implementations, they typically take the form of shared library files with extensions like .so or .dll .

• load expects a complete filename including an extension. require is usually passed a library name, with no extension, rather than a filename. In that case, it searches for a file that has the library name as its base name and an appropriate source or native library extension. If a directory contains both an .rb source file and a binary extension file, require will load the source file instead of the binary file.

• load can load the same file multiple times. require tries to prevent multiple loads of the same file. (require can be fooled, however, if you use two different, but equivalent, paths to the same library file. In Ruby 1.9, require expands relative paths to absolute paths, which makes it somewhat harder to fool.) require keeps track of the files that have been loaded by appending them to the global array
$" (also known as $LOADED_FEATURES ). load does not do this.

• load loads the specified file at the current $SAFE level. require loads the specified library with $SAFE set to 0 , even if the code that called require has a higher value for that variable. See §10.5 for more on $SAFE and Ruby’s security system. (Note that if $SAFE is set to a value higher than 0 , require will refuse to load any file with a tainted filename or from a world-writable directory. In theory, therefore, it should be safe for require to load files with a reduced $SAFE level.)

11. What is string interpolation in Ruby?
We can embedded an expression in double coded string using curly brackets preceding with #. This is called string interpolation.
Name =”vijay”
Puts “My name is #{name}”

12. what is the difference between dup and clone methods in Ruby?

The Ruby built-in methods Object#clone and #dup produce copies of their receiver. They differ in the amount of context they copy. The dup method copies just the object's content, whereas clone also preserves things such as singleton classes associated with the object.

s1 = "cat"
def s1.upcase
"CaT"
end

s1_dup = s1.dup
s1_clone = s1.clone
s1 #=> "cat"
s1_dup.upcase #=> "CAT" (singleton method not copied)
s1_clone.upcase #=> "CaT" (uses singleton method)

13. Difference between include and extend in Ruby?

Include is for adding methods to an instance of a class and extend is for adding class methods

module Foo
def foo
puts 'heyyyyoooo!'
end
end

class Bar
include Foo
end

Bar.new.foo # heyyyyoooo!
Bar.foo # NoMethodError: undefined method ‘foo’ for Bar:Class

class Baz
extend Foo
end

Baz.foo # heyyyyoooo!
Baz.new.foo # NoMethodError: undefined method ‘foo’ for #<Baz:0x1e708>

As you can see, include makes the foo method available to an instance of a class and extend makes the foo method available to the class itself.

14. Defining attr_access like methods in Ruby?
class Demo
def self.test_accessor (*args)
args.each do |e|
define_method(e) do
puts instance_variable_get("@#{e}")
end
define_method("#{e}=") do |val|
instance_variable_set("@#{e}",val)
end
end
end
test_accessor :hello,:vijay
end

15. What is the output of x=1/2 in ruby?
0 # zero
Division of one integer by another results in a truncated integer. This is a feature, not a bug. If you need a floating point number, make sure that at least one operand is a floating point.

16. Write a method in Ruby to display given number of Fibonacci series?
def fibonacci(n)
a,b = 0,1
n.times do
printf("%d\n", a)
a,b = b,a+b
end
end

17. Difference between String and Symbol in ruby?

Symbols are Strings, just with an important difference, Symbols are immutable. Mutable objects can be changed after assignment while immutable objects can only be overwritten.

String: Strings are mutable, the Ruby interpreter never knows what that String may hold in terms of data. As such, every String needs to have its own place in memory.

Example:
puts "hello world".object_id # => 3102960
puts "hello world".object_id # => 3098410

Symbol: Every Symbol shares the same object id, and as such the same space on the heap. To further increase performance, Ruby will not mark Symbols for destruction, allowing you to reuse them again and again. Symbols are not only stored in memory, they are also keep track of via an optimized Symbols dictionary.

Example:
puts :"hello world".object_id # => 239518
puts :"hello world".object_id # => 239518

18. What is true, false and nil in ruby?

true evaluates to an object that is a singleton instance of TrueClass. Likewise, false and nil are singleton instances of FalseClass and NilClass.

Note that true, false, and nil refer to objects, not numbers. false and nil are not the same thing as 0, and true is not the same thing as 1. nil behaves like false, and any value other than nil or false behaves like true.

19. Garbage collection in Ruby?

ObjectSpace.garbage_collect, which forces Ruby’s garbage collector to run. Garbage collection functionality is also available through the GC module. GC.start is a synonym for ObjectSpace.garbage_collect. Garbage collection can be temporarily disabled with GC.disable, and it can be enabled again with GC.enable.

20. Program to find given String is palindrome or not?

def palindrome?(str)
str.length <= 1 or (str[0,1] == str[-1,1] and palindrome?(str[1..-2]))
end

puts palindrome?("aja")

Without Recursion call:

def palindrome?(string)
string == string.reverse
end

21. Difference between Array and Hash in Ruby?

Arrays: Arrays are used to store collections of data. Each object in an array has an unique key assigned to it.
We can access any object in the array using this unique key.
The positions in an array starts from " 0 ". The first element is located at " 0 ", the second at 1st position etc.

A Hash is a collection of key-value pairs. It is similar to an Array, except that indexing is done via arbitrary keys of any object type,
not an integer index.
Hashes enumerate their values in the order that the corresponding keys were inserted.

So we use arrays when the order matters
We use hashes when we want the convenience of refering to objects by their labels

22. Program to reverse the given line in Ruby?

words = %w(Son I am able she said)
str = ""
words.reverse_each { |w| str += "#{w} "} # str is now "said she able am I Son "

23. Program to find given number is prime or not?

def prime?(n)
prime = false
factor = 1
if n== 0 or n == 1
prime = false
end

for i in 1..(n-1)
if n%i == 0
factor = i
end
end

if factor > 1
prime = false
else
prime = true
end
return prime
end

24. Program to find given number is palindrome or not ?

def palindrome?(n)

num = n

while n>0
dig = n%10
reverse = reverse*10 + dig
n = n/10
end

if num == reverse
return true
else
return false
end
end

25. Program to find given number is odd or even?

def odd_even?(n)
if n%2 == 0
return true
else
return false
end
end

26. Program to print reverse of the given string?

def str_reverse str

reverse = ‘ ‘
chars = str.each_char.to_a
chars.size.times { reverse << chars.pop}
puts reverse
end

27. How to instantiate a module self.method in a class?

If you want to have both class methods and instance methods mixed into a class when including a module, you may follow the pattern:
YourModule
module ClassMethods
def a_class_method
puts "I'm a class method"
end
end

def an_instance_method
puts "I'm an instance method"
end

def self.included(base)
base.extend ClassMethods
end
end

class Whatever
include YourModule
end

Whatever.a_class_method
# => I'm a class methodmodule

Whatever.new.an_instance_method
# => I'm an instance method

28. Object-oriented programming in Ruby

http://railsknowledge.blogspot.in/2014/10/object-oriented-programming-in-ruby.html

Object-oriented programming in Ruby

2014-10-24T02:52:00.000-07:00

Object-oriented programming in Ruby

There are three widely used programming paradigms there.

Procedural programming

Functional programming

Object-oriented programming.

Ruby is an object-oriented language. It has some functional and procedural features too.

Object-oriented programming (OOP) is a programming paradigm that uses objects and their interactions to design applications and computer programs.

There are some basic programming concepts in OOP:

Abstraction

Polymorphism

Encapsulation

Inheritance

The abstraction is simplifying complex reality by modeling classes appropriate to the problem.

The polymorphism is the process of using an operator or function in different ways for different data input.

The encapsulation hides the implementation details of a class from other objects.

The inheritance is a way to form new classes using classes that have already been defined.

Objects

Objects are basic building blocks of a Ruby OOP program. An object is a combination of data and methods. In a OOP program, we create objects. These objects communicate together through methods.

Each object can receive messages, send messages and process data.

There are two steps in creating an object.

First, we define a class. A class is a template for an object. It is a blueprint, which describes the state and behavior that the objects of the class all share.

A class can be used to create many objects. Objects created at runtime from a class are called instances of that particular class.

#!/usr/bin/ruby
class Being
end

b = Being.new
puts b

In our first example, we create a simple object.

class Being
end

This is a simple class definition. The body of the template is empty. It does not have any data or methods.

b = Being.new

We create a new instance of the Being class. For this we have the new method. The b variable stores the newly created object.

puts b

We print the object to the console to get some basic description of the object.

What does it mean, to print an object? When we print an object, we in fact call its to_s method. But we have not defined any method yet. It is because every object created inherits from the base Object. It has some elementary functionality, which is shared among all objects created. One of this is the to_s method.

$ ./simple.rb
#<Being:0x9f3c290>

We get the object class name.

The constructor

A constructor is a special kind of a method. It is automatically called, when the object is created. Constructors do not return values. The purpose of the constructor is to initiate the state of an object. The constructor in Ruby is called initialize. Constructors do not return any values.

Constructors cannot be inherited. The constructor of a parent object is called with a super method. They are called in the order of inheritance.

#!/usr/bin/ruby

class Being

    def initialize
        puts "Being is created"
    end

end

Being.new

We have a Being class.

The Being class has a constructor method called initialize. It prints a message to the console. The definition of a Ruby method is placed between the def and end keywords.

Being.new

An instance of the Being class is created. At the moment of the object creation, the constructor method is called.

$ ./constructor.rb
Being is created

This is the output of the program.

Object attributes is the data bundled in an instance of a class. The object attributes are called instance variables or member fields. An instance variable is a variable defined in a class, for which each object in the class has a separate copy.

In the next example, we initiate data members of the class. Initiation of variables is a typical job for constructors.

#!/usr/bin/ruby

class Person

    def initialize name
        @name = name
    end

    def get_name
        @name
    end

end

p1 = Person.new "Jane"
p2 = Person.new "Beky"

puts p1.get_name
puts p2.get_name
In the above Ruby code, we have a Person class with one member field.

class Person
    def initialize name
        @name = name
    end

In the constructor of the Person class, we set a member field to a value name. The name parameter is passed to the constructor at creation. A constructor is a method called initialize that is being called at the creation of an instance object. The @name is an instance variable. Instance variables start with @ character in Ruby.

def get_name
@name
end

The get_name method returns the member field. In Ruby member fields are accessible only via methods.

p1 = Person.new "Jane"
p2 = Person.new "Beky"

We create two objects of a Person class. A string parameter is passed to each object constructor. The names are stored inside instance variables that are unique to each object.

puts p1.get_name
puts p2.get_name

We print the member fields by calling the get_name on each of the objects.

$ ./person.rb
Jane
Beky

We see the output of the program. Each instance of the Person class has its own name member field.

We can create an object without calling the constructor. Ruby has a special allocate method for this. The allocate method allocates space for a new object of a class and does not call initialize on the new instance.

#!/usr/bin/ruby

class Being

   def initialize
       puts "Being created"
   end
end

b1 = Being.new
b2 = Being.allocate
puts b2

In the example, we create two objects. The first object using the new method, the second object using the allocate method.

b1 = Being.new

Here we create an instance of the object with the new keyword. The constructor method initialize is called and the message is printed to the console.

b2 = Being.allocate
puts b2

In case of the allocate method, the constructor is not called. We call the to_s method with the puts keyword to show, that the object was created.

$ ./allocate.rb
Being created
#<Being:0x8ea0044>

Output of the program.

Constructor overloading

Constructor overloading is the ability to have multiple types of constructors in a class. This way we can create an object with different number or different types of parameters.

Ruby has no constructor overloading that we know from other programming languages.

This behaviour can be simulated to some extent with default parameter values in Ruby.

#!/usr/bin/ruby

class Person

    def initialize name="unknown", age=0
        @name = name
        @age = age
    end

    def to_s
        "Name: #{@name}, Age: #{@age}"
    end

end

p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"

p p1, p2, p3, p4

This example shows how we could simulate constructor overloading on a Person class that has two member fields. If we do not specify the name of the person, we have "unknown" string instead. For unspecified age we have 0.

def initialize name="unknown", age=0
@name = name
@age = age
end

The constructor takes two parameters. They have a default value. The default value is used, if we do not specify our own values at the object creation. Note that the order of parameters must be kept. First comes the name, then the age.

p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"

p p1, p2, p3, p4

We create four objects. The constructors take different number of parameters.

$ ./consover.rb
Name: unknown, Age: 0
Name: unknown, Age: 17
Name: Becky, Age: 19
Name: Robert, Age: 0

Output of the example.

Methods

Methods are functions defined inside the body of a class. They are used to perform operations with the attributes of our objects. Methods are essential in encapsulation concept of the OOP paradigm. For example, we might have a connect method in our AccessDatabase class. We need not to be informed, how exactly the method connects to the database. We only have to know, that it is used to connect to a database. This is essential in dividing responsibilities in programming. Especially in large applications.

In Ruby, data is accessible only via methods.

#!/usr/bin/ruby

class Person

    def initialize name
        @name = name
    end

    def get_name
        @name
    end

end

per = Person.new "Jane"

puts per.get_name
puts per.send :get_name

The example shows two basic ways to call a method.

puts per.get_name

The common way is to use a dot operator on an object followed by a method name.

puts per.send :get_name

The alternative is to use a built-in send method. It takes a symbol of the method to be called as a parameter.

Methods typically perform some action on the data of the object.

#!/usr/bin/ruby

class Circle

    @@PI = 3.141592

    def initialize
        @radius = 0
    end

    def set_radius radius
        @radius = radius
    end

    def area
        @radius * @radius * @@PI
    end

end

c = Circle.new
c.set_radius 5
puts c.area

In the code example, we have a Circle class. We define two methods.

@@PI = 3.141592

We have defined a @@PI variable in our Circle class. It is a class variable. Class variables start with @@ sigils in Ruby. Class variables belong to a class, not to an object. Each object has access to its class variables. We use the @@PI to compute the area of the circle.

def initialize
@radius = 0
end

We have one member field. It is the radius of the circle. If we want to modify this variable from the outside, we must use the publicly available set_radius method. The data is protected.

def set_radius radius
@radius = radius
end

This is the set_radius method. It gives the @radius instance variable a new value.

def area
@radius * @radius * @@PI
end

The area method returns the area of a circle. This is a typical task for a method. It works with data and produces some value for us.

c = Circle.new
c.set_radius 5
puts c.area

We create an instance of the Circle class. And set its radius by calling the set_radius method on the object of the circle. We use the dot operator to call the method.

$ ./circle.rb
78.5398

Running the example.

Access modifiers

Access modifiers set the visibility of methods and member fields. Ruby has three access modifiers:

public, protected and private.

In Ruby, all data members are private. Access modifiers can be used only on methods.

Ruby methods are public, unless we say otherwise.

The public methods can be accessed from inside the definition of the class as well as from the outside of the class.

The difference between the protected and the private methods is subtle.

They both cannot be accessed outside the definition of the class. They can be accessed only within the class itself and by inherited or parent classes.

Note that unlike in other object-oriented programming languages, inheritance does not play role in Ruby access modifiers.

Only two things are important. First, if we call the method inside or outside the class definition. Second, if we use or do not use the self keyword which points to the current receiver.

Access modifiers protect data against accidental modifications. They make the programs more robust. The implementation of some methods is subject to change. These methods are good candidates for being private. The interface that is made public to the users should only change when really necessary. Over the years users are accustomed to using specific methods and breaking backward compatibility is generally frowned upon.

#!/usr/bin/ruby

class Some

     def method1
         puts "public method1 called"
     end

    public

     def method2
         puts "public method2 called"
     end

     def method3
         puts "public method3 called"
         method1
         self.method1
     end
end

s = Some.new
s.method1
s.method2
s.method3

The example explains the usage of public Ruby methods.

def method1
puts "public method1 called"
end

The method1 is public, even if we did not specify the public access modifier. It is because methods are public by default, if not specified otherwise.

public

def method2
puts "public method2 called"
end

...

Methods following the public keyword are public.

def method3
    puts "public method3 called"
    method1
    self.method1
end

From inside the public method3, we call other public method. With and without the self keyword.

s = Some.new
s.method1
s.method2
s.method3

Public methods are the only methods that can be called outside the definition of a class as shown here.

$ ./public_methods.rb
public method1 called
public method2 called
public method3 called
public method1 called
public method1 called

Running the example.

The next example looks at private methods.

#!/usr/bin/ruby

class Some

    def initialize
        method1
        # self.method1
    end

    private

     def method1
         puts "private method1 called"
     end

end

s = Some.new
# s.method1

Private methods are tightest methods in Ruby. They can be called only inside a class definition and without the self keyword.

def initialize
method1
# self.method1
end

In the constructor of the method, we call the private method1. Calling the method with the self is commented. Private methods cannot be specified with a receiver.

private

def method1
puts "private method1 called"
end

Methods following the private keyword are private in Ruby.

s = Some.new
# s.method1

We create an instance of the Some class. Calling the method outside the class definition is prohibited. If we uncomment the line, the Ruby interpreter gives an error.

$ ./private_methods.rb
private method called

Output of the example code.

Finally, we will work with protected methods. The distinction between the protected and the private methods in Ruby is subtle. Protected methods are like private. There is only one small difference. They can be called with the self keyword specified.

#!/usr/bin/ruby

class Some

    def initialize
        method1
        self.method1
    end

    protected

     def method1
         puts "protected method1 called"
     end

end

s = Some.new
# s.method1

The above example shows protected method in usage.

def initialize
method1
self.method1
end

Protected methods can be called with and without the self keyword.

protected

def method1
puts "protected method1 called"
end

Protected methods are preceded by the protected keyword.

s = Some.new
# s.method1

Protected methods cannot be called outside the class definition. Uncommenting the line would lead to an error.

Inheritance

The inheritance is a way to form new classes using classes that have already been defined. The newly formed classes are called derived classes, the classes that we derive from are called base classes. Important benefits of inheritance are code reuse and reduction of complexity of a program. The derived classes (descendants) override or extend the functionality of base classes (ancestors).

#!/usr/bin/ruby

class Being

    def initialize
        puts "Being class created"
    end
end

class Human < Being

   def initialize
       super
       puts "Human class created"
   end
end

Being.new
Human.new

In this program, we have two classes. A base Being class and a derived Human class. The derived class inherits from the base class.

class Human < Being

In Ruby, we use the < operator to create inheritance relations. The Human class inherits from the Being class.

def initialize
super
puts "Human class created"
end

The super method calls the constructor of the parent class.

Being.new
Human.new

We instantiate the Being and the Human class.

$ ./inheritance.rb
Being class created
Being class created
Human class created

First the Being class is created. The derived Human class also calls the costructor of its parent.

An Object may be involved in comlicated relationships. A single object can have multiple ancestors. Ruby has a method ancestors which gives a list of ancestors for a specific class.

Each Ruby object is automatically a descendant of Object, BasicObject classes and Kernel Module. They are built-in the core of the Ruby language.

#!/usr/bin/ruby

class Being
end

class Living < Being
end

class Mammal < Living
end

class Human < Mammal
end

p Human.ancestors

We have four classes in this example. A Human is a Mammal a Living and a Being.

p Human.ancestors

We print the ancestors of a Human class.

$ ./ancestors.rb
[Human, Mammal, Living, Being, Object, Kernel, BasicObject]

A Human class has three custom and three built-in ancestors.

A more complex example follows.

#!/usr/bin/ruby

class Being

    @@count = 0

    def initialize
        @@count += 1
        puts "Being class created"
    end

    def show_count
        "There are #{@@count} beings"
    end

end

class Human < Being

   def initialize
       super
       puts "Human is created"
   end
end

class Animal < Being

   def initialize
       super
       puts "Animal is created"
   end
end

class Dog < Animal

   def initialize
       super
       puts "Dog is created"
   end
end

Human.new
d = Dog.new
puts d.show_count

We have four classes. The inheritance hierarchy is more complicated. The Human and the Animal classes inherit from the Being class. And the Dog class inherits directly from the Animal class and further from the Being class. We also use a class variable to count the number of beings created.

@@count = 0

We define a class variable. A class variable begins with @@ sigils and it belongs to the class, not to the instance of the class. We use it to count the number of beins created.

def initialize
@@count += 1
puts "Being class created"
end

Each time the Being class is instantiated, we increase the @@count variable by one. This way we keep track of the number of instances created.

class Animal < Being
...

class Dog < Animal
...

The Animal inherits from the Being and the Dog inherits from the Animal. Further, the Dog inherits from the Being as well.

Human.new
d = Dog.new
puts d.show_count

We create instances from the Human and from the Dog classes. We call the show_count method on the Dog object. The Dog class has no such method; the grandparent's (Being) method is called then.

$ ./inheritance2.rb
Being class created
Human is created
Being class created
Animal is created
Dog is created
There are 2 beings

The Human object calls two constructors. The Dog object calls three constructors. There are two Beings instantiated.

Inheritance does not play role in the visibility of methods and data members. This is a notable difference from many common object-oriented programming languages.

In C# or Java, private data members and methods are not inherited. Only public and protected. In contrast to this, private data members and methods are inherited in Ruby as well. The visibility of data members and methods is not affected by inheritance in Ruby.

#!/usr/bin/ruby

class Base

    def initialize
        @name = "Base"
    end

    private

     def private_method
         puts "private method called"
     end

    protected

     def protected_method
         puts "protected_method called"
     end

    public

     def get_name
         return @name
     end
end

class Derived < Base

    def public_method
        private_method
        protected_method
    end
end

d = Derived.new
d.public_method
puts d.get_name

In the example we have two classes. The Derived class inherits from the Base class. It inherits all three methods and one data field.

def public_method
private_method
protected_method
end

In the public_method of the Derived class we call one private and one protected method. They were defined in the parent class.

d = Derived.new
d.public_method
puts d.get_name

We create an instance of the Derived class. We call the public_method. And call the get_name method, which returns the private @name variable. Remember that all instance variables are private in Ruby. The get_name method returns the variable regardless of the fact, that it is private and defined in the parent class.

$ ./inheritance3.rb
private method called
protected_method called
Base

The output of the example confirms that in Ruby language, public, protected, private methods and private member fields are inherited by child objects from their parents.

The super method

The super method calls a method of the same name in the parent's class. If the method has no arguments it automatically passes all its arguments. If we write super() no arguments are passed to parent's method.

#!/usr/bin/ruby

class Base

    def show x=0, y=0
        p "Base class, x: #{x}, y: #{y}"
    end
end

class Derived < Base

    def show x, y
        super
        super x
        super x, y
        super()
    end
end

d = Derived.new
d.show 3, 3

In the example, we have two classes in a hierarchy. They both have a show method. The show method in the Derived class calls the show method in the Base class using the super method.

def show x, y
    super
    super x
    super x, y
    super()
end

The super method without any arguments calls the parent's show method with the arguments that were passed to the show method of the Derived class. In our case x=3, y=3. The super() method passes no arguments to the parent's show method.

$ ./super.rb
"Base class, x: 3, y: 3"
"Base class, x: 3, y: 0"
"Base class, x: 3, y: 3"
"Base class, x: 0, y: 0"

Output of the example.

What is the difference between collect,select, reject and inject in ruby?

2014-10-23T23:58:00.003-07:00

What is the difference between collect,select, reject and inject in ruby?

Some of the most commonly used Enumerable iterators are the rhyming methods collect , select , reject , and inject .

The collect method (also known as map ) executes its associated block for each element of the enumerable object, and collects the return values of the blocks into an array:

squares = [1,2,3].collect {|x| x*x} # => [1,4,9]

The select method invokes the associated block for each element in the enumerable

object, and returns an array of elements for which the block returns a value other than false or nil . For example:

evens = (1..10).select {|x| x%2 == 0} # => [2,4,6,8,10]

The reject method is simply the opposite of select ; it returns an array of elements for

which the block returns nil or false . For example:

odds = (1..10).reject {|x| x%2 == 0} # => [1,3,5,7,9]

The inject method is a little more complicated than the others. It invokes the associated

block with two arguments. The first argument is an accumulated value of some sort from previous iterations. The second argument is the next element of the enumerable object. The return value of the block becomes the first block argument for the next iteration, or becomes the return value of the iterator after the last iteration.

data = [2, 5, 3, 4]

sum = data.inject {|sum, x| sum + x } # => 14 (2+5+3+4)

floatprod = data.inject(1.0) {|p,x| p*x } # => 120.0 (1.0*2*5*3*4)

max = data.inject {|m,x| m>x ? m : x } # => 5 (largest element)

What is the difference between Ruby 1.8.7 and 1.9.2?

2014-10-23T23:52:00.003-07:00

What is the difference between Ruby 1.8.7 and 1.9.2?

a).Pseudo-Keyword Hash Syntax

Ruby 1.9 adds a cool feature that lets you write things like:

foo(a: 1, b: 2)

But on Ruby 1.8, we’re stuck using the old key => value syntax:

foo(:a => 1, :b => 2)

b).Multisplat Arguments

Ruby 1.9.1 offers a downright insane amount of ways to process arguments to methods.

def add(a,b,c,d,e)

a + b + c + d + e

end

add(*[1,2], 3, *[4,5]) #=> 15

The closest thing we can get to this on Ruby 1.8 would be something like this:

add(*[[1,2], 3, [4,5]].flatten) #=> 15

c). Block-Local Variables

On Ruby 1.9, block variables will shadow outer local variables, resulting in the following behavior:

>> a = 1

=> 1

>> (1..10).each { |a| a }

=> 1..10

>> a

=> 1

This is not the case on Ruby 1.8, where the variable will be modified even if not explicitly set:

>> a = 1

=> 1

>> (1..10).each { |a| a }

=> 1..10

>> a

=> 10

d). Block Arguments

In Ruby 1.9, blocks can accept block arguments, which is most commonly seen in define_method:

define_method(:answer) { |&b| b.call(42) }

However, this won’t work on Ruby 1.8 without some very ugly workarounds

e).New Proc Syntax

Both the stabby Proc and the .() call are new in 1.9, and aren’t parseable by the Ruby 1.8 interpreter. This means that calls like this need to go:

>> ->(a) { a*3 }.(4)

=> 12

Instead, use the trusty lambda keyword and Proc#call or Proc#[]:

>> lambda { |a| a*3 }[4]

=> 12

f).Using Enumerator

In Ruby 1.9, you can get back an Enumerator for pretty much every method that iterates over a collection:

>> [1,2,3,4].map.with_index { |e,i| e + i }

=> [1, 3, 5, 7]

In Ruby 1.8, Enumerator is part of the standard library instead of core, and isn’t quite as feature-packed. However, we can still accomplish the same goals by being a bit more verbose:

>> require "enumerator"

=> true

>> [1,2,3,4].enum_for(:each_with_index).map { |e,i| e + i }

=> [1, 3, 5, 7]

g). String Iterators

In Ruby 1.8, Strings are Enumerable, whereas in Ruby 1.9, they are not. Ruby 1.9 provides String#lines, String#each_line, String#each_char, and String#each_byte, all of which are not present in Ruby 1.8.

h). Character Operations

In Ruby 1.9, strings are generally character-aware, which means that you can index into them and get back a single character, regardless of encoding:

>> "Foo"[0]

=> "F"

This is not the case in Ruby 1.8.6, as you can see:

>> "Foo"[0]

=> 70

i).Encoding Conversions

Ruby 1.9 has built-in support for transcoding between various character encodings, whereas Ruby 1.8 is more limited. However, both versions support Iconv. If you know exactly what formats you want to translate between, you can simply replace your string.encode("ISO-8859-1") calls with something like this:

Iconv.conv("ISO-8859-1", "UTF-8", string)

j).Introduction of Fibers

Fibers are light-weight threads with manual, cooperative scheduling, rather than the preemptive scheduling of Ruby 1.8's threads.A fiber gets interrupted only when it yields its execution. So a fiber is a sort of user-managed thread. Threads use pre-emptive scheduling, whereas fibers use cooperative scheduling.

What is the difference between Proc and Lambda?

2014-10-23T23:43:00.002-07:00

What is the difference between Proc and Lambda?

Blocks are syntactic structures in Ruby; they are not objects, and cannot be manipulated

as objects. It is possible, however, to create an object that represents a block. Depending

on how the object is created, it is called a proc or a lambda .

Procs have block-like behavior and lambdas have method-like behavior. Both, however, are instances of class Proc .

Creating & invoking procs:

p = Proc.new {|x,y| x+y }

p.call(1,2)

Creating & invoking Lamdas:

succ = lambda {|x| x+1} =>Ruby1.8

succ = ->(x){x>0} =>Ruby1.9

succ.call(1)

● In a lambda-created proc, the return statement returns only from the proc itself

● In a Proc.new-created proc, the return statement is a little more surprising: it returns control not just from the proc, but also from the method enclosing the proc!

Differences:

Procs

Lambda

A proc is the object form of a block, and it behaves like a block.

Calling a proc is like yielding to a block.

A proc is like a block, so if you call a proc that executes a return statement, it attempts

to return from the method that encloses the block that was converted to the proc.

For Example:

def test

puts "entering method"

p = Proc.new { puts "entering proc"; return }

p.call # Invoking the proc makes method return

puts "exiting method" # This line is never executed

end

test

break to do the same thing like return in a proc.

proc handles the arguments it receives flexibly:discarding extras, silently adding nil for omitted arguments.

p = Proc.new {|x,y| print x,y }

p.call(1,2) # prints 1,2

p.call(1) # prints 1, nil

A lambda has slightly

modified behavior and behaves more like a method than a block.

whereas calling a lambda is like invoking a method.

A return statement in a lambda returns from the lambda itself, not from the method that surrounds the creation site of the lambda:

For Example:

def test

puts "entering method"

p = lambda { puts "entering lambda"; return }

p.call

# Invoking lambda does not make the method #return

puts "exiting method"

# This line *is* executed now

end

test

break to do the same thing like return in a lambda.

Lambdas are not flexible in this way; like methods, they must be invoked with precisely

the number of arguments they are declared with:

l = lambda {|x,y| print x,y }

l.call(1,2) # This works

l.call(1) # Wrong number of arguments

next statement works the same in a block, proc, or lambda.

redo also works the same in procs and lambdas.

retry is never allowed in procs or lambdas: using it always results in a LocalJumpError.

raise behaves the same in blocks, procs, and lambdas. Exceptions always propagate up the call stack

dynamic programing in rails controller

2013-08-14T02:04:00.002-07:00

Here is the simple code snippet for dynamic programming in rails controllers.

def method_missing(c)
render_error(404)
end

The above method will be invoked when there was method missing exception was raised and we are redirected the request to specific page like 404.

Thank You,
Uma Mahesh

git commands

2013-08-14T01:07:00.001-07:00

Here are the list of useful git commands.

> git config -l

List all variables set in config file.

> git config --global user.name "uma mahesh"
> git config --global user.email "umamaheshvarma@gmail.com"

Thank You,
Uma Mahesh.

postgresql console interface

2013-07-13T00:09:00.002-07:00

Here is the command to connect to postgresql through console,

> sudo -u postgres psql

The above command will connect to psql.

> sudo -u postgres psql
psql (9.1.9)
Type "help" for help.

postgres=#

Now you can run all the sql queries through this interface.

Thank You,
Uma Mahesh.

2013-07-10T03:02:00.003-07:00

Hi,

While working with rspec I had issue as shown below.

undefined method `visit' for #<RSpec::Core::ExampleGroup::Nested_5::Nested_1

I didn't change any code modifications in the spces and my spces started failing with the error shown above. I have searched for the solution and I didn't found any specific solution for that. At last I came to find the issue is due to change in the Rspec version in my gem file.

I reverted back to my old gem file and finally able to solve the issue.

Thank You,
Uma Mahesh.

couldn't find file 'twitter/bootstrap'

2013-06-16T08:01:00.001-07:00

Twitter Bootstrap in rails application not working in production while deployed to heroku.

When I check for logs in heroku, I am able to see the below error.

ActionView::Template::Error (couldn't find file 'twitter/bootstrap')

While doing some google I came to see that, I have included 'twitter-bootstrap-rails' gem in development env in my gem file. So it was unable to load in production.

I have made the 'twitter-bootstrap-rails' gem public and bundle install again. Now every thing works fine.

Thank You,
Uma Mahesh.

sqlite3 error while pusing code to heroku

2013-06-16T07:50:00.000-07:00

Below is the issue while I am trying to push the code to heroku for the first time.

rails@rails:/media/AAFA1CCBFA1C95A3/ruby/rails_app/simple_form/sample1$ git push heroku master
Counting objects: 99, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (88/88), done.
Writing objects: 100% (99/99), 39.73 KiB, done.
Total 99 (delta 3), reused 0 (delta 0)

-----> Ruby/Rails app detected
-----> Installing dependencies using Bundler version 1.3.2
       Running: bundle install --without development:test --path vendor/bundle --binstubs vendor/bundle/bin --deployment
       Fetching gem metadata from https://rubygems.org/.........
       Fetching gem metadata from https://rubygems.org/..
       Installing rake (10.0.4)
       Installing i18n (0.6.1)
       Installing multi_json (1.7.7)
       Installing activesupport (3.2.13)
       Installing builder (3.0.4)
       Installing activemodel (3.2.13)
       Installing erubis (2.7.0)
       Installing journey (1.0.4)
       Installing rack (1.4.5)
       Installing rack-cache (1.2)
       Installing rack-test (0.6.2)
       Installing hike (1.2.3)
       Installing tilt (1.4.1)
       Installing sprockets (2.2.2)
       Installing actionpack (3.2.13)
       Installing mime-types (1.23)
       Installing polyglot (0.3.3)
       Installing treetop (1.4.14)
       Installing mail (2.5.4)
       Installing actionmailer (3.2.13)
       Installing arel (3.0.2)
       Installing tzinfo (0.3.37)
       Installing activerecord (3.2.13)
       Installing activeresource (3.2.13)
       Installing rack-ssl (1.3.3)
       Installing json (1.8.0)
       Installing rdoc (3.12.2)
       Installing thor (0.18.1)
       Installing railties (3.2.13)
       Installing bootstrap-daterangepicker-rails (0.0.5)
       Installing coffee-script-source (1.6.2)
       Installing execjs (1.4.0)
       Installing coffee-script (2.2.0)
       Installing coffee-rails (3.2.2)
       Installing commonjs (0.2.6)
       Installing jquery-rails (3.0.1)
       Installing less (2.2.1)
       Installing less-rails (2.2.3)
       Installing libv8 (3.3.10.4)
       Using bundler (1.3.2)
       Installing rails (3.2.13)
       Installing sass (3.2.9)
       Installing sass-rails (3.2.6)
       Installing simple_form (2.1.0)
       Installing sqlite3 (1.3.7)
       Gem::Installer::ExtensionBuildError: ERROR: Failed to build gem native extension.
       /usr/local/bin/ruby extconf.rb
       checking for sqlite3.h... no
       sqlite3.h is missing. Try 'port install sqlite3 +universal'
       or 'yum install sqlite-devel' and check your shared library search path (the
       location where your sqlite3 shared library is located).
       *** extconf.rb failed ***
       Could not create Makefile due to some reason, probably lack of
       necessary libraries and/or headers. Check the mkmf.log file for more
       details. You may need configuration options.
       Provided configuration options:
       --with-opt-dir
       --without-opt-dir
       --with-opt-include
       --without-opt-include=${opt-dir}/include
       --with-opt-lib
       --without-opt-lib=${opt-dir}/lib
       --with-make-prog
       --without-make-prog
       --srcdir=.
       --curdir
       --ruby=/usr/local/bin/ruby
       --with-sqlite3-dir
       --without-sqlite3-dir
       --with-sqlite3-include
       --without-sqlite3-include=${sqlite3-dir}/include
       --with-sqlite3-lib
       --without-sqlite3-lib=${sqlite3-dir}/lib
       --enable-local
       --disable-local
       Gem files will remain installed in /tmp/build_27eau1y5d86jq/vendor/bundle/ruby/1.9.1/gems/sqlite3-1.3.7 for inspection.
       Results logged to /tmp/build_27eau1y5d86jq/vendor/bundle/ruby/1.9.1/gems/sqlite3-1.3.7/ext/sqlite3/gem_make.out
       An error occurred while installing sqlite3 (1.3.7), and Bundler cannot continue.
       Make sure that `gem install sqlite3 -v '1.3.7'` succeeds before bundling.
!
!     Failed to install gems via Bundler.
!

!     Push rejected, failed to compile Ruby/Rails app

To git@heroku.com:simple-form-app.git
! [remote rejected] master -> master (pre-receive hook declined)
error: failed to push some refs to 'git@heroku.com:simple-form-app.git'

Solution:

Add this to your Gemfile,

group :production do
  gem 'pg'
end
group :development, :test do
  gem 'sqlite3'
end

then do a bundle then repush to heroku. You cannot use sqlite3 on Heroku - which is the cause of the error.

Thank You,
Uma Mahesh.

helper method from rails console

2013-06-12T09:42:00.000-07:00

Hi,

I would like to test the helper method from the rails console. Can any one suggest me how I can invoke a helper method from console?

Thank You,
Uma Mahesh.

how to run rails console in production environment

2013-05-24T00:06:00.000-07:00

We run the below command for getting into rails console.

> rails c

By default it will load the development environment. But some time you may need to run in production env to check some configuration variables.

You can run the rails console by specific environment with the below command.

> RAILS_ENV=production rails console

This will load the production environment setting to the console env.

Thank You,
Uma Mahesh.

Synchronous and Asynchronous difference

2013-05-16T01:35:00.000-07:00

Hi,

Many of the folks are quite confused about the Synchronous and Asynchronous request in web application. May of us know that AJAX is an asynchronous request. But what does asynchronous mean?

Asynchronous request will not wait for response for an request. Let me explain with an example.

function Namecheck(){
var avilability = 1;
avilability = get_status("/user/check_name");
if avilability == 1
{
alert('avilable');
}
else{
alert('Not avilable');
}
}

In the above case 'get_status' will send an ajax request to "user/check_name" and it will not wait for the response for that request as it is an asynchronous, there by we always get the javascript alert as "avilable". So the function will execute without ant wait for response. This is how asynchronous request will work.

Synchronous request is the one which will wait until the complete response was received.

Note: to over come the response issue with AJAX we will use callback to trigger a function once the complete request was done with receiving a response.

Thank You,
Uma Mahesh

Email domain validation in ruby

2013-05-14T03:08:00.000-07:00

Hi,

Most of the web applications will have registration forms and every form will have email field as the mandatory. We use regular expression to validate the email format. But some times we may come across tio validate the given email id was valid or not that means does the domain exists or not.

Below is the useful code to validate the domain name in ruby with the help of MX records.

In email_validation.rb

require 'resolv'

class EmailValidation
def self.validate_email_domain(email)
domain = email.match(/\@(.+)/)[1]
Resolv::DNS.open do |dns|
@mx = dns.getresources(domain, Resolv::DNS::Resource::IN::MX)
end
puts @mx.size > 0 ? true : false
end
end

s = EmailValidation.validate_email_domain("umamaheshvarma@gmail.com")

The above method will return true if the domain exists.

Thank You,
Uma Mahesh

Guest user functionality in rails app

2012-11-28T01:15:00.000-08:00

Hi,

In many requirements you may be asked to provide guest user functionality in application. Here are the simple steps to make that functionality simple.

rails g migration add_guest_to_users guest:boolean
rake db:migrate

index.html.erb
<p><%= button_to "Guest User!", users_path, method: :post %></p>

layouts/application.html.erb
Logged in as <strong><%= current_user.name %></strong>.
<% if current_user.guest? %>
<%= link_to "Become a member", signup_path %>
<% else %>
<%= link_to "Log Out", logout_path %>
<% end %>

user_controller.rb
def create
@user = params[:user] ? User.new(params[:user]) : User.new_guest
if @user.save
    current_user.move_to(@user) if current_user && current_user.guest?
    session[:user_id] = @user.id
    redirect_to root_url
else
    render "new"
end
end

models/user.rb
class User < ActiveRecord::Base
has_many :tasks, dependent: :destroy

attr_accessible :username, :email, :password, :password_confirmation

validates_presence_of :username, :email, :password_digest, unless: :guest?
validates_uniqueness_of :username, allow_blank: true
validates_confirmation_of :password

# override has_secure_password to customize validation until Rails 4.
require 'bcrypt'
attr_reader :password
include ActiveModel::SecurePassword::InstanceMethodsOnActivation

def self.new_guest
    new { |u| u.guest = true }
end

def name
    guest ? "Guest" : username
end

def move_to(user)
    tasks.update_all(user_id: user.id)
end
end

lib/tasks/guests.rake
namespace :guests do
desc "Remove guest accounts more than a week old."
task :cleanup => :environment do
    User.where(guest: true).where("created_at < ?", 1.week.ago).destroy_all
end
end

By applying above simple steps you can add guest user functionality in existing rails application easily .

Thank You,
Uma Mahesh.

ruby 1.9.3 perfomance

2012-11-28T00:00:00.001-08:00

Hi,

Recently I have read article about ruby performance issue compared to ruby 1.9.2 and ruby 1.9.3 and came to see few important points that need to be noted. Below is the discussion.

We just switched a site from Apache + ruby 1.9.2 to nginx + ruby 1.9.3 a few days ago and I noticed that somehow the site speed has noticably dropped on the ruby side of things and I just couldn’t understand why.


/opt/nginx/logs# rvm use 1.9.3
Using /usr/local/rvm/gems/ruby-1.9.3-p327
/opt/nginx/logs# time ruby -e "count = 0; while(count < 100000000); count = count + 1; end; puts count"
100000000

real 0m7.655s
user 0m7.632s
sys 0m0.012s

/opt/nginx/logs# rvm use 1.9.2
Using /usr/local/rvm/gems/ruby-1.9.2-p320
/opt/nginx/logs# time ruby -e "count = 0; while(count < 100000000); count = count + 1; end; puts count"
100000000

real 0m4.716s
user 0m4.716s
sys 0m0.000s

Checking make.log showed that 1.9.3 was indeed compiled w/o any optimizations. After I hand-compiled a 1.9.3, I got this:


/opt/ruby193opt/bin# ./ruby -v
ruby 1.9.3p327 (2012-11-10 revision 37606) [x86_64-linux]
/opt/ruby193opt/bin# time ./ruby -e "count = 0; while(count < 100000000); count = count + 1; end; puts count"
100000000

real 0m4.641s
user 0m4.628s
sys 0m0.008s

/opt/ruby193opt/bin# ruby -v
ruby 1.9.2p320 (2012-04-20 revision 35421) [x86_64-linux]
puck352:/opt/ruby193opt/bin# time ruby -e "count = 0; while(count < 100000000); count = count + 1; end; puts count"
100000000

real 0m4.634s
user 0m4.624s
sys 0m0.012s

Now it performs on par with 1.9.2

Thank You,
Uma Mahesh.