Blocks or simply chunks of code as in the last example may be existing variables which changes after that same variable passes thought the block, giving it a new value. Blocks may also be used to return a needed value to the method as in the last example, the resulting value of the last expression the data was exposed to was returned back to the method as the pre-set value of the yield statement till the condition which was the set maximum value of the Fibonacci Series that was set to 1000. This is why the find method which is used for array class objects work. The method find is actually defined in the enumerable module thrown into the array class mix. The Next Post, shows a sample code using the find method.

Sample Code using find :

class Array
def find
for a in 0…size
value = himself[a]
return value in yield(value)
end
return nil
end
end
[1, 3, 5, 7, 9].find {|v| v*v >30}

The code has elements passed successively to the attached block which returns true if the method sends in a corresponding element. If none match, then nil is returned which is a very good example of how to best utilize iterators. The Array class is simply doing what it was designed to which is to access the contents of an array leaving the application to do what it is supposed to do which in this case is to find entries that satisfies a set criteria.

After it goes through the block, the file is closed taking with it the results of the block’s transactional process. This is something that should be done with all programming languages, to have the code have their own built-in file handling system which ensures that a file once opened is closed upon exit to avoid destroying the contents of that file. This shows the two forms the File.open method’s behavior can be called upon, that if it is called with a block it does what it has to and then automatically closes the file. Called on without the block and it returns the file object.

The sample code above shows the number of techniques that can be used to maximize the use of blocks for transactional control where the takeAndDosomething method is considered a class method and that it can be called independent or without influence of any single File Object. We used it to function in the same manner as the File.open method without consideration of any arguments. We called the File.open method, passed onto it the transaction or condition which was defined in the *args as a parameter. Shortening it all, the “openAndDosomething” transparently passes whatever conditions or parameters it gets towards the File.open method. Once the file ios open and the “openAndDosomething” calls on the yield statement passing the opened file to the block/chunk of code.

That’s where blocks come in, to simplify the definition and use of these buttons making maintenance simpler so we could call the specific block to which we pass on the necessary parameters or methods to attain the final outcome. Below is an example of how this can be achieved with blocks creating a class called devicebutton:

class DeviceButton < Button
def initialize(label, &process)
super(label)
@action = action
end
def buttonSelected
@action.call(self)
end
end

bPlay = DeviceButton.new(“Play”) {cdList.play}
bPause = DeviceButton.new(“Pause”) {cdList.pause}

Sample Code:

class PlayButton < Button
def initialize
super(“Play”) # invoke Button’s initialize process
end
def buttonSelected
# do something that should be done when the start button is pressed
end
end

bPlay = PlayButton.new

This type of approach would bring about two very problematic scenarios; one, the actions that are to be done when a button is selected and pressed is not a function of the button itself but of the overall device which has the buttons as interface; and last, this would have us making tons of buttons that would correspond to all the function the overall device that if the said button’s features or process were to change that would create a ton of maintenance issues in efforts to re-define those buttons to do all the different functions buttons should do in the whole application/device.

As it turns out, blocks are the ideal tool for use ion implementing user interfaces where we have a defined graphic that signifies a button and pressing that button would result in a pre-set series of processes. A simple button definition can be:

bPlay = Button.new(“Play”)
bPause = Button.new(“Pause”)
# so on and so forth……

If a user presses any of the buttons it calls on the pre-set reactions/processes that are supposed to happen if the user requests that action, say a method called “buttonSelected” will be called upon. The said method would then have to have it’s own method as a sub-class of the button action sub-class. This can be done by defining the sub-class such as the sample code in the next post would show.

Blocks or chunks of code that can be used for transactional control which in our example would have it open a file, process it then make sure that same file is closed after processing before exiting the code. There is an automatic function that ensures this and we will discuss it further in the following example which is a form of simple (meaning it does not take into consideration any errors whatsoever) code below.

class File
def File.takeAndDosomething(*args)
f=File.open(*args)
yield f
f.close()
end
end

File.takeAndDosomething(“testfile”, “r”) do |aFile|
print while aFile.gets
end

This sample code would give you the following output:
This is line one
This is line two
This is line three
And so on……………

The results will be discussed in the next post where we dissect what we have just done.

Anytime the “yield” statement is called upon it calls on the chunk of code within the block executing it returning control to where the yield statement was called continuing on its way till the process is finished. That’s where the magic of Ruby is, that a block can be made to function like a method in itself. This allows processes to embedded and used again and again with minimal coding required to achieve the desired result. The Following post would have blocks used as transactional controllers which use them to do a process that is similar somewhat to the way methods work when they are called upon.

An iterator is a method of calling on a block of code which is somewhat similar to C, Java or Perl, somewhat. The usage of iterators in Ruby does something different as opposed to other languages that share similar functions. Initially a block normally appears adjacent a method or call, that call statement is written immediately after the method’s last parameter. Next, the chunk of code contained within the block is not done as it is executed rather it is remembered then has the code continue into the method. Then the block can be called as if it were a method in itself with the use of the “yield” statement.

Below, we find sample code which uses block to return the values of the Fibonacci number Series.

def fibMax(max)
a1, a2 =1,1 # variables that are assigned parallel values
while a1 <= max
yield a1
a1, a2 = a2, a1+a2
end
end
fibMax(1000) {|f| print f, ” “}

The above code gives us the value of the Fibonacci series numbers till the number 1000 which is the set maximum number to reach.

Sample Code Output:
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

The above example shows how the block(chunk of code) processed the Fibonacci Series of numbers, returning only those that fell within the set limit of 1000.