Re: sandwhich principle (ruby koans)

Roelof,

This principle says that when you have two pieces of code that are almost
identical, except for the "middle" part, you can create a method that takes
a block to fill the "middle" part.

For example, suppose you have two methods, and both need to save
information to a log file before and after execution:

def hello
  save_in_logfile "Starting to execute method 'hello'"
  puts "first method"
  save_in_logfile "Finishing execution of method 'hello'"
end

def world
  save_in_logfile "Starting to execute method 'world'"
  puts "second method"
  save_in_logfile "Finishing execution of method 'world'"
end

The "sandwich" the koan talks about could be interpreted as the
save_in_logfile methods being the slices of bread and the puts calls the
meat. So we could use blocks to create this:

def sandwich(string)
  save_in_logfile "Starting to execute method '#{string}'"
  yield
  save_in_logfile "Finishing to execute method '#{string}'"
end

And the two methods would become:

def hello
  sandwich("hello") do
    puts "first method"
  end
end

def world
  sandwich("world") do
    puts "second method"
  end
end

This way, the repetitive part (save_in_logfile stuff) is called in only one
place. This technique is used in the File::open method - when you call it
with a block, the opened file is automatically closed after the block is
executed.

Hope that helps!

2012/9/24 Roelof Wobben <[e-mail]>

>  hello,
>
> I'm working on ruby koans.
>
> Now I have to do some sandwhich code.
>
> The exercise looks like this :
>
> require File.expand_path(File.dirname(__FILE__) + '/edgecase')
> class AboutSandwichCode < EdgeCase::Koan
>   def count_lines(file_name)
>     file =3D open(file_name)
>     count =3D 0
>     while line =3D file.gets
>       count +=3D 1
>     end
>     count
>   ensure
>     file.close if file
>   end
>   def test_counting_lines
>     assert_equal 4, count_lines("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def find_line(file_name)
>     file =3D open(file_name)
>     while line =3D file.gets
>       return line if line.match(/e/)
>     end
>   ensure
>     file.close if file
>   end
>   def test_finding_lines
>     assert_equal "test\n", find_line("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   # THINK ABOUT IT:
>   #
>   # The count_lines and find_line are similar, and yet different.
>   # They both follow the pattern of "sandwich code".
>   #
>   # Sandwich code is code that comes in three parts: (1) the top slice
>   # of bread, (2) the meat, and (3) the bottom slice of bread.  The
>   # bread part of the sandwich almost always goes together, but
>   # the meat part changes all the time.
>   #
>   # Because the changing part of the sandwich code is in the middle,
>   # abstracting the top and bottom bread slices to a library can be
>   # difficult in many languages.
>   #
>   # (Aside for C++ programmers: The idiom of capturing allocated
>   # pointers in a smart pointer constructor is an attempt to deal with
>   # the problem of sandwich code for resource allocation.)
>   #
>   # Consider the following code:
>   #
>   def file_sandwich(file_name)
>     file =3D open(file_name)
>     yield(file)
>   ensure
>     file.close if file
>   end
>   # Now we write:
>   def count_lines2(file_name)
>     file_sandwich(file_name) do |file|
>       count =3D 0
>       while line =3D file.gets
>         count +=3D 1
>       end
>       count
>     end
>   end
>   def test_counting_lines2
>     assert_equal 4, count_lines2("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def find_line2(file_name)
>     # Rewrite find_line using the file_sandwich library function.
>   end
>   def test_finding_lines2
>     assert_equal __, find_line2("example_file.txt")
>   end
>   # ------------------------------------------------------------------
>   def count_lines3(file_name)
>     open(file_name) do |file|
>       count =3D 0
>       while line =3D file.gets
>         count +=3D 1
>       end
>       count
>     end
>   end
>   def test_open_handles_the_file_sandwich_when_given_a_block
>     assert_equal __, count_lines3("example_file.txt")
>   end
> end
>
> But I don't get the principle.
> Can anyone explain this to me ?
>
> Roelof
>
>
>



--=20
Carlos Agarie
Control engineering student
Polytechnic School
University of S=E3o Paulo