notebooks/ReadWriteTextFiles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "formed-sequence",
   "metadata": {},
   "source": [
    "# Read/Write Text Files in Ruby\n",
    "\n",
    "Let's look at how we can read/write to a text file with the help of a simple program:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "liquid-klein",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas dignissim tellus quis neque ultrices, non dapibus quam consectetur. Cras vulputate bibendum cursus. Sed dictum ex ex, nec lobortis nulla consequat id. Fusce vel euismod lectus. Nulla vel mollis elit. Mauris quis turpis justo. Donec non quam cursus, accumsan ligula in, volutpat massa. Sed nec feugiat sapien. Quisque egestas faucibus quam vitae viverra. Integer ultrices, diam sit amet rhoncus semper, nibh dolor pellentesque odio, id blandit justo ante ut felis. Maecenas id rutrum metus. Phasellus at ultrices tortor, at vehicula dolor. Sed egestas massa blandit, faucibus urna id, scelerisque dui. Quisque ut quam ut tortor mattis vestibulum. In posuere pellentesque metus et sollicitudin.\n",
      "\n",
      "\n",
      "\n",
      "Mauris interdum imperdiet egestas. In quis enim eget nibh semper fringilla id eget risus. Vestibulum volutpat quis lacus ac tristique. Cras dapibus sollicitudin metus. Proin quis tortor nec ligula vulputate fermentum. Donec dignissim enim orci, eu varius velit mollis non. Sed eu accumsan dui. Mauris et mauris condimentum elit dictum posuere. Maecenas in porta est. In hac habitasse platea dictumst. Donec id aliquet ex, eget sollicitudin arcu. Vestibulum magna diam, dictum vitae ultricies et, malesuada a nunc.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "=begin\n",
    "Open and read from a text file\n",
    "Note that since a block is given, file will automatically be closed when the block terminates\n",
    "=end\n",
    "File.open('assets/LoremIpsum.txt') do |f|\n",
    "  while line = f.gets\n",
    "    puts line\n",
    "  end\n",
    "end\n",
    "\n",
    "# Create a new file and write to it\n",
    "File.open('/tmp/test.rb', 'w') do |f|\n",
    "  # use \"\\n\" fro two lines of text\n",
    "  f.puts \"Created by Carlos\\nThank you!\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "auburn-november",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "\n",
    "- [Traversing Directory Trees](#Traversing-Directory-Trees)\n",
    "- [Random Access](#Random-Access)\n",
    "- [Does Ruby allow Object Serialization?](#Does-Ruby-allow-Object-Serialization?)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "academic-deadline",
   "metadata": {},
   "source": [
    "The `File.open` method can open the file in different modes like:\n",
    "\n",
    "- `'r'` Read-only, starts at beginning of file (default)\n",
    "- `'r+'` Read/Write, starts at beginning of file\n",
    "- `'w'` Write-only, truncates existing file to zero length or creates a new file for writing\n",
    "\n",
    "File modes can work like:\n",
    "\n",
    "```ruby\n",
    "<file mode><:external encoding><:internal>\n",
    "```\n",
    "\n",
    "Let us say you know that the external encoding is in _UTF-16LE_ and you want the internal in _UTF-8_, then you can write:\n",
    "\n",
    "```ruby\n",
    "File.open('LoremIpsum.txt', 'r:UTF-16LE:UTF-8') do |f|\n",
    "```\n",
    "\n",
    "Please check the [online documentation]() for a full list of modes available.\n",
    "\n",
    "`File.open` opens a new file if there is no associated block. If the optional block is given, it will be passed file as an argument, and the file will automatically be closed when the blick terminates.\n",
    "\n",
    "_Always close a file that you open. In the case of a file open for writing, this is very important and can actually prevent lost data._\n",
    "\n",
    "`File` implements a `readlines` method that reads an entire file into an array, line by line.\n",
    "\n",
    "> Both class methods `open` and `readlines` belong to the `IO` class, whose sub-class is `File`. We have not done classes, objects, inheritance yet but for the record these two methods are inherited by the sub-class `File` from the class `IO`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "italian-aaron",
   "metadata": {},
   "source": [
    "## Traversing Directory Trees\n",
    "\n",
    "The `Find` module supports top-down traversal of a set of file paths, given as arguments to the `find` method. If an argument is a directory, then its name and name of all its files and sub-directories will be passed in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "specific-slovak",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D: ./\n",
      "F: ./Arrays.ipynb\n",
      "F: ./Blocks.ipynb\n",
      "F: ./FlowControl.ipynb\n",
      "F: ./Hashes.ipynb\n",
      "F: ./Methods.ipynb\n",
      "F: ./Names.ipynb\n",
      "F: ./Numbers.ipynb\n",
      "F: ./Quickstart.ipynb\n",
      "F: ./RandomNumbers.ipynb\n",
      "F: ./Ranges.ipynb\n",
      "F: ./ReadWriteTextFiles.ipynb\n",
      "F: ./Strings.ipynb\n",
      "F: ./Symbols.ipynb\n",
      "D: ./assets\n",
      "F: ./assets/LoremIpsum.txt\n",
      "F: ./assets/hellospain.rb\n"
     ]
    }
   ],
   "source": [
    "require 'find'\n",
    "Find.find('./') do |f|\n",
    "  type = case\n",
    "         when File.file?(f) then \"F\"\n",
    "         when File.directory?(f) then \"D\"\n",
    "         else \"?\"\n",
    "         end\n",
    "  puts \"#{type}: #{f}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adapted-insertion",
   "metadata": {},
   "source": [
    "We shall talk about `require` soon [here](IncludingOtherFiles.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cardiac-struggle",
   "metadata": {},
   "source": [
    "## Random Access\n",
    "\n",
    "It's quite easy to access a file randomly. Let's say we have a text file (named _assets/hellospain.rb_), the contents of which is shown below:\n",
    "\n",
    "```ruby\n",
    "puts 'Hello Spain'\n",
    "```\n",
    "\n",
    "We now need to display the contents of the file from the word _Spain_. Here's how:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "interpreted-heaven",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spain'"
     ]
    }
   ],
   "source": [
    "# We want to display the contents of the file from the word Spain\n",
    "f = File.new(\"assets/hellospain.rb\")\n",
    "f.seek(12, IO::SEEK_SET)\n",
    "print f.readline\n",
    "f.close"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "refined-potter",
   "metadata": {},
   "source": [
    "Ruby supports the notion of a file pointer. The file pointer indicates the current location in the file. The `File.new` method opens the file _hellospain.rb_ in _read-only_ mode (default mode), returns a new `File` object and the file pointer is positioned at the beginning of the file. In the above program, the next statement is `f.seek(12, IO::SEEK_SET)`. The `seek` method of class [`IO`](https://ruby-doc.org/core-3.0.0/IO.html), moves the file pointer to a given integer distance (first parameter of `seek` method) in the stream according to the value of the second parameter in the `seek` method.\n",
    "\n",
    "- `IO::SEEK_CUR` - Seeks to first integer number parameter plus current position\n",
    "- `IO::SEEK_END` - Seeks to first integer number parameter plust end of stream (you probably want a negative value for the first integer number parameter)\n",
    "- `IO::SEEK_SET` - Seeks to the absolute location given by first integer number parameter\n",
    "\n",
    "More on the scope operator `::` [here](Constants.ipynb)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cellular-policy",
   "metadata": {},
   "source": [
    "## Does Ruby allow Object Serialization?\n",
    "\n",
    "Java features the ability to serialize objects, letting you store them somewhere and reconstitute them when needed. Ruby calls this kinkd of serialization _marshaling_. Saving an object and some or all of its components is done using the method `Marshal.dump`. Later on you can reconstitute the object using `Marshal.load`. Ruby uses marshaling to store session data. Refer topic [_Object Serialization_](ObjectSerialization.ipynb) later on."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 3.0.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "3.0.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}