Seven Languages In Seven Weeks: Ruby - Day 2

# Print the contents of an array of sixteen numbers, four numbers
# at a time, using just each. Now, do the same with each_slice in
# Enumerable.


# First, let's build up our array. We can use a Range's Enumerable
# properties to build our array of values.

values = (1..16).to_a();

# Now, we're going to loop over the values using each. However, in
# order to output 4 values at a time, we're gonna only do so on
# certain indexes.
#
# Since we don't have any insight into which value we are looking
# at (index-wise), we're going to keep an internal stack of
# values which we will output only when it reaches a length of 4.
# However, I can't figure out how to do this with *just* each. As
# such, I am creating an external stack.

valueStack = [];

# Now, loop over each element in the array.

values.each{ |value|

	# Push the current iteration value onto the stack.

	valueStack.push( value );

	# Check to see if the value stack has reached a length of 4. If
	# so, we are going to output it.

	if (valueStack.length == 4)

		# Output the stack of 4 values as a list.

		puts( valueStack.join( ", " ) );

		# Reset the value stack to prepare it to collect the next
		# four values in the array.

		valueStack = [];

	end

};

# Print the contents of an array of sixteen numbers, four numbers
# at a time, using just each. Now, do the same with each_slice in
# Enumerable.


# First, let's build up our array. We can use a Range's Enumerable
# properties to build our array of values.

values = (1..16).to_a();


# This time, we are going to iterate over the array, four elements
# at a time, using the each_slice() method. This allows us to look
# at sections of an array as sub-arrays.

values.each_slice( 4 ){ |valueStack|

	# Output the sub-section of the array as a list.

	puts( valueStack.join( ", " ) );

};

# The Tree class was interesting, but it did not allow you to
# specify a new tree with a clean user interface. Let the initailizer
# accept a nested structure with hashes and arrays. You should be
# able to specific a tree like this: .....


# The Tree Class

class Tree

	attr_accessor :childNodes;
	attr_accessor :name;


	# I return an initialized Tree instance.

	def initialize( treeData )

		# Initialize the node variables. By default, we are going
		# to treat this node as the root node (unless the incoming
		# tree data only has one top-level key, in which case that
		# will be the root node).

		@name = "root";
		@childNodes = [];

		# Check to see how many top-level keys the tree data has.
		# If it only has one, we can use it to define this tree
		# node; if it has more than one, will have to treat it as
		# the child data of a the "root" node.

		if (treeData.size() == 1)

			# We only have one top-level key. We can use that to
			# define this tree node.

			@name = treeData.keys()[ 0 ];

			# Convert the sub-level tree data into the chile nodes
			# of this tree node.

			treeData[ @name ].each{ |key, value|

				@childNodes.push(
					Tree.new( { key => value } )
				);

			};

		else

			# We have more than one top-level key. We need to
			# create a root node to house multiple nodes.

			treeData.each{ |key, value|

				@childNodes.push(
					Tree.new( { key => value } )
				);

			};

		end

	end


	# I visit all decendant nodes in a depth-first traversal.

	def visitAll( &block )

		# Visit this node.

		visit( &block );

		# Visit all of this node's children.

		childNodes.each{ |c|

			c.visitAll( &block );

		}

	end


	# I visit just this node.

	def visit( &block )

		block.call( self );

	end

end



# ------------------------------------------------------------ #
# ------------------------------------------------------------ #
# ------------------------------------------------------------ #
# ------------------------------------------------------------ #


# Create our new Tree.

tree = Tree.new(
	{
		"grandpa" => {
			"dad" => {
				"child1" => {},
				"child2" => {}
			},
			"uncle" => {
				"child3" => {},
				"child4" => {}
			}
		}
	}
);


# Visit all nodes in the tree, starting with the root.

tree.visitAll{ |node|

	puts( "Visiting #{node.name}" );

};

# The first thing we are going to do is build up the file content
# we are going to be searching. In this case, we are going to be
# building up the content using Ruby's "Here Document" notation.

content = <<END_CONTENT_BUFFER.strip().gsub( /^\t*/m, "" )

	I definitely think that Helena Bonham Carter is hot. I
	know people will disagree with me here... and maybe she's
	not hot in the most mundane sense; but, there's something just
	absolutely stunning about her. Plus, she's a wonderful actress
	which makes her seem all that much hotter. If you haven't seen
	"Conversations With Other Women," I'd recommend it. She plays
	qutie well opposite Aaron Eckhart. Plus, it was the first
	movie I've ever seen her in knickers - it's refreshing to see a
	woman who can be hot without feeling like she has to be a twig.

END_CONTENT_BUFFER

# Create a connection to the relative-path file (relative to the
# current directory of execution).

contentFile = File.new( "./data.txt", "w" );

# Write the content to the file.

contentFile.puts( content );

# Since we opened this file as "writing", we need to close it -
# we can't use it for reading.

contentFile.close();


# ------------------------------------------------------------ #
# ------------------------------------------------------------ #
# ------------------------------------------------------------ #
# ------------------------------------------------------------ #


# Set the phrase that we're going to be searching for within the
# file. This could also be gotten from the standard IO (command
# line), but we'll hard-code it for now.

targetPhrase = "hot";


# Open the data file for searching. Notice that we are opening
# the file with a code block; in doing it this way, we don't
# have to explicitly close the file when we're done - Ruby will
# take care of that for us.

File.open( "./data.txt", "r" ){ |fileStream|

	# Read the file in, one line at a time, until we reach the
	# end of the file. Gets() will return the line or return nil
	# when it hits the end of the file.

	while ( line = fileStream.gets())

		# When Ruby uses a file, it appears to create meta data
		# about the line that's been read in and the line number.
		# I'm defining both here for reference, but am not using
		# all of it (since we assinged line above).

		lineContent = $_;
		lineNumber = $.;

		# Check the current line to see if it contains the given
		# phrase. To make the search a bit more flexible, we are
		# going to use a case-insensitive regular expression. Notice
		# that a regular expression literal can use variable
		# subistitution via the #{var} notation. The "o" pattern
		# modifier indicates that this subsitution only takes place
		# the first time the pattern is evaluated (I don't fully
		# understand what that means).
		#
		# NOTE: This assumes no reg-ex special charactrers are within
		# our pattern.

		if (line =~ /#{targetPhrase}/io)

			# Output the current line with the line number. When
			# you open a file,

			puts( "Line #{lineNumber}: #{line}" );

		end

	end

}