Ruby and OO for Beginners

Ruby and OO

Cory Foy | @cory_foyhttp://www.coryfoy.com

Triangle.rb

June 24, 2014

Thursday, June 26, 14

Triangle.rb MeetupJune 25th, 2012

Cory Foy | @cory_foyhttp://www.coryfoy.comRuby and OO

Overview• What is Ruby?• Ruby Basics• Advanced Ruby• Wrap-up




What is Ruby?• First released in 1995 by Yukihiro

Matsumoto (Matz)• Object-Oriented

– number = 1.abs #instead of Math.abs(1)• Dynamically Typed

– result = 1+3




What is Ruby?

• http://www.rubygarden.org/faq/entry/show/3

class Person attr_accessor :name, :age # attributes we can set and retrieve def initialize(name, age) # constructor method @name = name # store name and age for later retrieval @age = age.to_i # (store age as integer) end def inspect # This method retrieves saved values "#{@name} (#{@age})" # in a readable format end end

p1 = Person.new('elmo', 4) # elmo is the name, 4 is the age puts p1.inspect # prints “elmo (4)”




Will It Change Your Life?• Yes!• Ok, Maybe• It’s fun to program with• And what is programming if it isn’t fun?




Ruby Basics• Variables, Classes and Methods• Properties / Attributes• Exceptions• Access Control• Importing Files and Libraries• Duck Typing




Ruby Basics - Variables• Local (lowercase, underscores)

– fred_j = Person.new(“Fred”)

• Instance (@ sign with lowercase)– @name = name

• Class (@@ with lowercase)– @@error_email = “[email protected]”

• Constant (Starts with uppercase)– MY_PI = 3.14– class Move

• Global ($ with name)– $MEANING_OF_LIFE = 42




Variables contain references to objects




Ruby Basics - Classes

• Class definitions are started with class,are named with a CamelCase name, and ended with end

class Move attr_accessor :up, :right def initialize(up, right) @up = up @right = right endend




Classes (and Modules) are Objects





• Attributes and fields normally go at the beginning of the class definition






• initialize is the same concept as a constructor from .NET or Java, and is called when someone invokes your object using Move.new to set up the object’s state





Ruby Basics - Methods

• Methods return the last expression evaluated. You can also explicitly return from methods

class Move def up @up end

def right return @right endend




Every Expression Evaluates to an Object





• Methods can take in specified parameters, and also parameter lists (using special notation)

class Move def initialize(up, right) @up = up @right = right endend




It’s All About Sending Messages to Objects





• Class (“Static”) methods start with either self. or Class.

class Move def self.create return Move.new end

def Move.logger return @@logger endend




Ruby Basics - Properties• Ruby supports the concept of

Properties (called Attributes)class Move def up @up endend

class Move def up=(val) @up = val endend

move = Move.newmove.up = 15puts move.up #15




Ruby Basics - Properties• Ruby also provides convenience

methods for doing thisclass Move attr_accessor :up #Same thing as last slideend

move = Move.newmove.up = 15puts move.up #15




Ruby Basics - Properties• You can specify read or write only

attributes as wellclass Move attr_reader :up #Can’t write attr_writer :down #Can’t readend

move = Move.newmove.up = 15 #errord = move.down #error




Ruby Basics - Exceptions• Ruby has an Exception hierarchy• Exceptions can be caught, raised and

handled• You can also easily retry a block of

code when you encounter an exception




Ruby Basics - Exceptionsprocess_file = File.open(“testfile.csv”)

begin #put exceptional code in begin/end block #...process file rescue IOError => io_error puts “IOException occurred. Retrying.” retry #starts block over from begin rescue => other_error puts “Bad stuff happened: “ + other_error else #happens if no exceptions occur puts “No errors in processing. Yippee!” ensure # similar to finally in .NET/Java process_file.close unless process_file.nil?end




Ruby Basics – Access Control

• Ruby supports Public, Protected and Private methods

• Private methods can only be accessed from the instance of the object, not from any other object, even those of the same class as the instance




Ruby Basics – Access Control• Access is controlled by using keywords

class Move private def calculate_move end #Any subsequent methods will be private until.. public def show_move end #Any subsequent methods will now be publicend




Ruby Basics – Access Control• Methods can also be passed as args

class Move def calculate_move end

def show_move end

public :show_move protected :calculate_moveend




Ruby Basics - Imports• To use a class from another file in your

class, you must tell your source file where to find the class you want to use

require ‘calculator’class Move def calculate_move return @up * Calculator::MIN_MOVE endend




Ruby Basics - Imports• There are two types of imports

– require• Only loads the file once

– load• Loads the file every time the method is executed

• Both accept relative and absolute paths, and will search the current load path for the file




Ruby Basics – Duck Typing• What defines an object?• How can you tell a car is a car?

– By model?– By name?

• Or, by it’s behavior?




Ruby Basics – Duck Typing

• We’d use static typing! So only the valid object could be passed in

• What if my object has the same behavior as a Car?

class CarWash def accept_customer(car)

endend

• How would we validate this in .NET or Java?




Ruby Basics – Duck Typing• What is

this?




Ruby Basics – Duck Typing• How

about this?




Ruby Basics – Duck Typing• What

about this?




Ruby Basics – Duck Typing• We know objects based on the behaviors and attributes the object possesses

• This means if the object passed in can act like the object we want, that should be good enough for us!




Ruby Basics – Duck Typing

• Or we could just let it fail as a runtime error

Class CarWash def accept_customer(car) if car.respond_to?(:drive_to) @car = car wash_car else reject_customer end endend




Advanced Ruby - Blocks• A block is just a section of code

between a set of delimters – { } or do..end

{ puts “Ho” }

3.times do puts “Ho “end #prints “Ho Ho Ho”




Advanced Ruby - Blocks• Blocks can be associated with method invocations.

The methods call the block using yielddef format_print puts “Confidential. Do Not Disseminate.” yield puts “© SomeCorp, 2006”end

format_print { puts “My name is Earl!” } -> Confidential. Do Not Disseminate. -> My name is Earl! -> © SomeCorp, 2006




Advanced Ruby - Blocks• We can check to see if a block was passed to our

methoddef MyConnection.open(*args) conn = Connection.open(*args) if block_given? yield conn #passes conn to the block conn.close #closes conn when block finishes end

return connend




Advanced Ruby - Iterators• Iterators in Ruby are simply methods

that can invoke a block of code• Iterators typically pass one or more

values to the block to be evaluated




Advanced Ruby - Iteratorsdef fib_up_to(max) i1, i2 = 1, 1 while i1 <= max yield i1 i1, i2 = i2, i1+i2 # parallel assignment endend

fib_up_to(100) {|f| print f + “ “}

-> 1 1 2 3 5 8 13 21 34 55 89

• Pickaxe Book, page 50




Advanced Ruby - Modules• At their core, Modules are like

namespaces in .NET or Java.module Kite def Kite.fly endend

module Plane def Plane.fly endend




Advanced Ruby - Mixins• Modules can’t have instances – they

aren’t classes• But Modules can be included in

classes, who inherit all of the instance method definitions from the module

• This is called a mixin and is how Ruby does “Multiple Inheritance”




Advanced Ruby - Mixinsmodule Print def print puts “Company Confidential” yield endend

class Document include Print #...end

doc = Document.newdoc.print { “Fourth Quarter looks great!” } -> Company Confidential -> Fourth Quarter looks great!




Advanced Ruby - Reflection• How could we call the Length of a

String at runtime in .NET?String myString = "test";int len = (int)myString .GetType() .InvokeMember("Length", System.Reflection.BindingFlags.GetProperty, null, myString, null);Console.WriteLine("Length: " + len.ToString());




Advanced Ruby - Reflection• In Ruby, we can just send the

command to the objectmyString = “Test”puts myString.send(:length) # 4




Advanced Ruby - Reflection• We can also do all kinds of fancy stuff#print out all of the objects in our systemObjectSpace.each_object(Class) {|c| puts c}

#Get all the methods on an object“Some String”.methods

#see if an object responds to a certain methodobj.respond_to?(:length)

#see if an object is a typeobj.kind_of?(Numeric)obj.instance_of?(FixNum)




Sending Can Be Very, Very Bad




Ruby Basics – Other Goodies• RubyGems – Package Management for

Ruby Libraries• Rake – A Pure Ruby build tool (can use

XML as well for the build files)• RDoc – Automatically extracts

documentation from your code and comments




Ruby Resources• Programming Ruby by Dave Thomas (the

Pickaxe Book)• http://www.ruby-lang.org• http://www.rubycentral.org• http://www.ruby-doc.org• http://www.triangleruby.com• http://www.manning.com/black3/• http://www.slideshare.net/dablack/wgnuby


http://www.ruby-lang.org

http://www.ruby-lang.org

http://www.triangleruby.com

http://www.triangleruby.com

http://www.manning.com/black3/

http://www.manning.com/black3/

http://www.slideshare.net/dablack/wgnuby

http://www.slideshare.net/dablack/wgnuby

Cory [email protected]

@cory_foy

blog.coryfoy.com

prettykoolapps.com

coryfoy.com


mailto:[email protected]

mailto:[email protected]

Software

Ruby and OO for Beginners