ch06-control-flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow (Chap 06)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conditional Execution: if (6.1.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "x=20; if x>10 then puts x end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GT\n"
     ]
    }
   ],
   "source": [
    "x=20\n",
    "if x>10\n",
    "    puts \"GT\"\n",
    "elsif x<10\n",
    "    puts \"LT\"\n",
    "elsif x==10\n",
    "    puts \"EQ\"\n",
    "else puts \"should never happen\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nil evaluates to false\n",
    "if nil; puts \"not gonna happen\"; end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NE 20\n",
      "NE 20\n"
     ]
    }
   ],
   "source": [
    "# negating conditions\n",
    "x=15\n",
    "if not (x==20)\n",
    "    puts \"NE 20\"\n",
    "end\n",
    "if !(x==20)\n",
    "    puts \"NE 20\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "small number\n"
     ]
    }
   ],
   "source": [
    "# unless = more \"natural\"\n",
    "x=15\n",
    "unless x>100\n",
    "    puts \"small number\"\n",
    "else\n",
    "    puts \"large number\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "big number\n",
      "big number\n"
     ]
    }
   ],
   "source": [
    "# conditional modifiers\n",
    "x=500\n",
    "puts \"big number\" if x>100\n",
    "puts \"big number\" unless x<=100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# conditional assignments\n",
    "x=1; y=2\n",
    "if false\n",
    "    x=3\n",
    "end\n",
    "p x; p y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<main>:1: warning: found `= literal' in conditional, should be ==\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy\n"
     ]
    }
   ],
   "source": [
    "# assignments in a conditional test\n",
    "if x=1 # assignment, not equality test\n",
    "    puts \"howdy\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found\n",
      "unmatched start: david a. b\n",
      "unmatched end: ck\n"
     ]
    }
   ],
   "source": [
    "# sometimes useful to combine assignment & testing,\n",
    "# esp if method returns nil or some other value\n",
    "# below: test string against regex\n",
    "\n",
    "name=\"david a. black\"\n",
    "if m = /la/.match(name)\n",
    "    puts \"found\"\n",
    "    puts \"unmatched start: \"+m.pre_match\n",
    "    puts \"unmatched end: \"+m.post_match\n",
    "else\n",
    "    puts \"no match\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### case statements (6.1.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "undefined local variable or method `response' for main:Object\nDid you mean?  respond_to?",
     "output_type": "error",
     "traceback": [
      "\u001b[31mNameError\u001b[0m: undefined local variable or method `response' for main:Object\nDid you mean?  respond_to?",
      "<main>:7:in `quit_or_not'",
      "<main>:16:in `<main>'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:44:in `eval'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:44:in `eval'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:12:in `eval'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:90:in `execute_request'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:49:in `dispatch'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:38:in `run'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/command.rb:110:in `run_kernel'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/command.rb:40:in `run'",
      "/var/lib/gems/2.7.0/gems/iruby-0.4.0/bin/iruby:5:in `<top (required)>'",
      "/usr/local/bin/iruby:23:in `load'",
      "/usr/local/bin/iruby:23:in `<main>'"
     ]
    }
   ],
   "source": [
    "response=\"yes\" # instead of gets, due to jupyter\n",
    "\n",
    "# ********************\n",
    "# DEBUG THIS ONE\n",
    "# ********************\n",
    "\n",
    "def quit_or_not\n",
    "    case response\n",
    "        when \"yes\"\n",
    "        puts \"bye\"\n",
    "        exit\n",
    "        when \"no\"\n",
    "        puts \"ok, more.\"\n",
    "    else \"unknown\"\n",
    "    end\n",
    "end\n",
    "quit_or_not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "same venue as ticket3\n"
     ]
    }
   ],
   "source": [
    "# example using implicit use of '===' for clause equality test\n",
    "class Ticket\n",
    "    attr_accessor :venue, :date\n",
    "    def initialize(venue,date)\n",
    "        self.venue=venue; self.date=date\n",
    "    end\n",
    "    def ===(other_ticket)\n",
    "        self.venue == other_ticket.venue\n",
    "    end\n",
    "end\n",
    "ticket1 = Ticket.new(  \"town hall\",\"7/8/18\")\n",
    "ticket2 = Ticket.new(\"conf center\",'7/8/18')\n",
    "ticket3 = Ticket.new(  \"town hall\",'8/9/18')\n",
    "case ticket1\n",
    "    when ticket2\n",
    "    puts \"same venue as ticket2\"\n",
    "    when ticket3\n",
    "    puts \"same venue as ticket3\"\n",
    "else\n",
    "    puts \"no match\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Loops (6.2)\n",
    "- you can loop __WHILE__ a condition is true, or\n",
    "- you can loop __UNTIL__ a condition is true.\n",
    "\n",
    "- code blocks can be enclosed in braces. (optional.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop control with break\n",
    "n=1;\n",
    "loop do\n",
    "    n+=1\n",
    "    break if n>9\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loop control; skips to next iteration\n",
    "n=1\n",
    "loop do\n",
    "    n+=1\n",
    "    next unless n==10\n",
    "    break\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "# while conditions\n",
    "n=1; while n<11\n",
    "    puts n; n+=1\n",
    "end\n",
    "puts \"done\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "# until conditions\n",
    "n=1; until n>10\n",
    "    puts n; n+=1\n",
    "end\n",
    "puts \"done\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<main>:1: warning: found `= literal' in conditional, should be ==\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# multiple assignements in conditionals\n",
    "if (a,b,c = [3,4,5])\n",
    "    puts a,b,c\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\t32.0\n",
      "10\t50.0\n",
      "20\t68.0\n",
      "30\t86.0\n",
      "40\t104.0\n",
      "50\t122.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0, 10, 20, 30, 40, 50]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# looping thru list of values\n",
    "class Temp\n",
    "    def Temp.c2f(cels)\n",
    "        cels*9.0/5 + 32\n",
    "    end\n",
    "end\n",
    "cels = [0,10,20,30,40,50]\n",
    "for c in cels\n",
    "    puts \"#{c}\\t#{Temp.c2f(c)}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterators & Code Blocks (6.3)\n",
    "- The job of _loop_ is to yield control to a code block, temporarily."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[10, 20, 30]\n",
      "#<Enumerator:0x0000556cbd1f7a78>\n"
     ]
    }
   ],
   "source": [
    "# curly braces vs do/end = difference in precedence\n",
    "\n",
    "array = [1,2,3]\n",
    "puts array\n",
    "puts array.map {  |n| n*10}\n",
    "puts array.map do |n| n*10 end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy0\n",
      "howdy1\n",
      "howdy2\n",
      "howdy3\n",
      "howdy4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# times\n",
    "5.times {|i| puts \"howdy\"+\"#{i}\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# each\n",
    "array=[1,2,3,4,5]\n",
    "array.each {|n| puts \"#{n}\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Array\n",
    "    def my_each\n",
    "        c=0\n",
    "        until c==size\n",
    "            yield self[c]\n",
    "            c+=1\n",
    "        end\n",
    "        self\n",
    "    end\n",
    "end\n",
    "a = [1,2,3,4,5]; a.my_each {|e| puts \"#{e}\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"JOHN\", \"PAUL\", \"GEORGE\"]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map - similar to each; map instead returns new array\n",
    "a = ['john','paul','george']\n",
    "a.map {|name| name.upcase}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "[3]\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# block params & variable scope\n",
    "def args\n",
    "    yield(1,2,3,4,5)\n",
    "end\n",
    "args do |a,b=1,*c,d,e|\n",
    "    puts a,b,c,d,e\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The temperature is now: 6 degrees Fahrenheit.\n",
      "Celsius\tFahrenheit\n",
      "0\t32.0\n",
      "10\t50.0\n",
      "20\t68.0\n",
      "30\t86.0\n",
      "40\t104.0\n",
      "50\t122.0\n",
      "60\t140.0\n",
      "70\t158.0\n",
      "80\t176.0\n",
      "90\t194.0\n",
      "100\t212.0\n",
      "212.0\n"
     ]
    }
   ],
   "source": [
    "# inspecting var behavior in a block\n",
    "class Temperature\n",
    "    def Temperature.c2f(celsius)\n",
    "        celsius * 9.0 / 5 + 32\n",
    "    end\n",
    "    def Temperature.now\n",
    "        rand(0..100)\n",
    "    end\n",
    "end\n",
    "celsius = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "fahrenheit = Temperature.now\n",
    "puts \"The temperature is now: #{fahrenheit} degrees Fahrenheit.\"\n",
    "puts \"Celsius\\tFahrenheit\"\n",
    "celsius.each do |c|\n",
    "    fahrenheit = Temperature.c2f(c)\n",
    "    puts \"#{c}\\t#{fahrenheit}\"\n",
    "end\n",
    "puts fahrenheit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Error Handling (6.4)\n",
    "- ```$ruby -cw filename.rb``` # tests code for syntax errors\n",
    "- common exceptions:\n",
    "![table 6.1](px/exceptions.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "was it zero?\n"
     ]
    }
   ],
   "source": [
    "# raising # rescuing exceptions\n",
    "begin\n",
    "    result=100/0 # divide by zero exception\n",
    "rescue\n",
    "    puts \"was it zero?\"\n",
    "    exit\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "was it zero?\n"
     ]
    }
   ],
   "source": [
    "# refined\n",
    "begin \n",
    "    result=100/0\n",
    "rescue ZeroDivisionError\n",
    "    puts \"was it zero?\"\n",
    "    exit\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nope, cant do that.\n"
     ]
    }
   ],
   "source": [
    "# using rescue in methods & code blocks\n",
    "def test_open_file\n",
    "    fh = File.open(\"bogus\")\n",
    "    yield fh\n",
    "    fh.close\n",
    "rescue\n",
    "    puts \"nope, cant do that.\"\n",
    "end\n",
    "test_open_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Switch to inspect mode.\n",
      "\n",
      "nope, cant do that.\n"
     ]
    }
   ],
   "source": [
    "# debugging with binding.irb\n",
    "# provides a way to open irb session from anywhere\n",
    "# in your program\n",
    "# (different behavior in Jupyter. try on cmndline.)\n",
    "def test_open_file\n",
    "    binding.irb\n",
    "    fh = File.open(\"bogus\")\n",
    "    yield fh\n",
    "    fh.close\n",
    "rescue\n",
    "    puts \"nope, cant do that.\"\n",
    "end\n",
    "test_open_file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"moore\", \"fwd\"]\n"
     ]
    }
   ],
   "source": [
    "# NoMethodError and safe navigation operator\n",
    "# common problem: methods accidentally called on nil.\n",
    "\n",
    "class Roster\n",
    "    attr_accessor :players\n",
    "end\n",
    "\n",
    "class Player\n",
    "    attr_accessor :name,:position\n",
    "    def initialize(name,position)\n",
    "        @name=name, @position=position\n",
    "    end\n",
    "end\n",
    "\n",
    "a = Player.new(\"moore\",\"fwd\")\n",
    "b = Player.new(\"taurasi\",\"gd\")\n",
    "\n",
    "r1 = Roster.new; r1.players = [a,b]\n",
    "r2 = Roster.new\n",
    "\n",
    "# use safe nav operator to avoid NoMethodError:\n",
    "if r1.players&.first&.position == \"fwd\" \n",
    "    puts \"#{r1.players.first.name}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nope.\n"
     ]
    }
   ],
   "source": [
    "# raising explicit exceptions\n",
    "def fussy(x)\n",
    "    raise ArgumentError, \"must be under 10\" unless x<10\n",
    "end\n",
    "\n",
    "begin\n",
    "    fussy(20)\n",
    "rescue ArgumentError\n",
    "    puts \"nope.\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "backtrace:\t\n",
      "[\"<main>:2:in `fussy'\", \"<main>:2:in `<main>'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:44:in `eval'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:44:in `eval'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/backend.rb:12:in `eval'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:90:in `execute_request'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:49:in `dispatch'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/kernel.rb:38:in `run'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/command.rb:110:in `run_kernel'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/lib/iruby/command.rb:40:in `run'\", \"/var/lib/gems/2.7.0/gems/iruby-0.4.0/bin/iruby:5:in `<top (required)>'\", \"/usr/local/bin/iruby:23:in `load'\", \"/usr/local/bin/iruby:23:in `<main>'\"]\n",
      "message:\t\n",
      "must be under 10\n"
     ]
    }
   ],
   "source": [
    "# capturing exception info\n",
    "begin\n",
    "    fussy(20)\n",
    "rescue ArgumentError => e\n",
    "    puts \"backtrace:\\t\"; puts e.backtrace\n",
    "    puts \"message:\\t\"; puts e.message\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":line_from_file"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ensure clause\n",
    "def line_from_file(filename,substring)\n",
    "    fh = File.open(filename)\n",
    "    begin\n",
    "        line = fh.gets\n",
    "        raise ArgumentError unless line.include?(substring)\n",
    "    rescue ArgumentError\n",
    "        puts \"invalid line\"\n",
    "        raise\n",
    "    ensure\n",
    "        fl.close\n",
    "    end\n",
    "    return line\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "about to...\n",
      "got an exception:\t MyNewException\n"
     ]
    }
   ],
   "source": [
    "# creating custom exception classes\n",
    "class MyNewException < Exception\n",
    "end\n",
    "begin\n",
    "    puts \"about to...\"\n",
    "    raise MyNewException\n",
    "rescue MyNewException => e\n",
    "    puts \"got an exception:\\t #{e}\"\n",
    "end"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.7.0",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}