notebooks/IncludingOtherFiles.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "compliant-second",
   "metadata": {},
   "source": [
    "# Including Other Files in Ruby\n",
    "\n",
    "When writing your first few Ruby programs, you tend to place all of your code in a single file. But as you grow as a Ruby programmer, your Ruby programs will also grow, and at some point you will realize that having a single file containing all of your code just won't do. It is easier to break your code up into logical groupings and place each group in a separate file or files. When you begin using multiple files, you have a need for the Ruby's `require` and `load` methods (both are global functions defined in `Object`, but are used like language keywords) that help you include other files in your program.\n",
    "\n",
    "The `load` method includes the named Ruby source file _every time_ the method is executed:\n",
    "\n",
    "```ruby\n",
    "load 'filename.rb'\n",
    "```\n",
    "\n",
    "The more commonly used `require` method loads any grive file _only once_:\n",
    "\n",
    "```ruby\n",
    "require 'filename'\n",
    "```\n",
    "\n",
    "`require` gives you access to the many extensions and programming libraries bundled with the Ruby programming language - as well as an even larger number of extensions and libraries written independently by other programmers and made available for use with Ruby.\n",
    "\n",
    "Note that you say `require 'filename'`, not `require 'filename.rb'`. Aside from looking nicer, this bareword way of referring to the extension is necessary because not all extensions use files ending in `.rb`. Specifically, extensions written in C are stored in files ending with `.so` or `.dll`. To keep the process transparent - that is, to save you the trouble of kwowing whether the extensions you want uses a `.rb` file or not-Ruby accepts a bareword and then does some automatic file-searching and trying out of possible filenames until it finds the file corresponding to the extension you have requested."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "regional-arbitration",
   "metadata": {},
   "source": [
    "```ruby\n",
    "require(string) => true or false\n",
    "```\n",
    "\n",
    "Ruby tries to load the library named string, returning `true` if successful. If the filename does not resolve to an absolute path, it will be searched for in the directories listed in `$:`. If the file has the extension `.rb`, it is loaded as a source file; if the extension is `.so`, `.o`, or `.dll`, or whatever the default shared library extension is on the current platform, Ruby loads the shared library as a Ruby extension. Otherwise, Ruby tries adding `.rb`, `.so`, and so on to the name. The name of the loaded feature is added to the array in `$:`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bound-queens",
   "metadata": {},
   "source": [
    "> **IN RAILS**: Rails uses `load` in preference to `require`, for example, in development mode - which means that if you're trying your application in a browser and making changes to the code at the same time, your changes are reloaded, overriding any caching behavior on the part of the Web server. Multiple `require` calls in the same place don't have the same effect if the application has already read the file in once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "assured-portable",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Engine Idle\n"
     ]
    }
   ],
   "source": [
    "require './assets/motorcycle'\n",
    "m = MotorCycle.new('Yamaha', 'yellow')\n",
    "m.start_engine"
   ]
  }
 ],
 "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
}