ch13-object-individualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Object individualization (Chap 13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Singletons"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "howdy.\n"
     ]
    }
   ],
   "source": [
    "# as shown earlier - you can define singleton methods\n",
    "# directly on individual objects\n",
    "obj = Object.new\n",
    "def obj.talk\n",
    "    puts \"howdy.\"\n",
    "end\n",
    "obj.talk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":makes"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# most common type of singleton method = the class method\n",
    "# - a method added to a class object, individual basis.\n",
    "class Car\n",
    "    def self.makes\n",
    "        %w{honda ford toyota chevy volvo}\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i am a string i am a string\n"
     ]
    }
   ],
   "source": [
    "# directly examining & modifying a singleton class\n",
    "# singleton classes = anonymous, but you can add instance methods, class methods, constant.\n",
    "# to do this:\n",
    "# class << object denotes anon singleton class of object.\n",
    "#   defs go here\n",
    "# end\n",
    "\n",
    "str = \"i am a string\"\n",
    "class << str\n",
    "    def twice # singleton method of the string str\n",
    "        self + \" \" + self\n",
    "    end\n",
    "end\n",
    "puts str.twice\n",
    "\n",
    "# class<<object notation usually for class-method definitions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Singleton classes in method lookup chain:\n",
    "![chain](px/Selection_174.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "david\n",
      "joe\n",
      "anonymous\n"
     ]
    }
   ],
   "source": [
    "# including a module in a singleton class\n",
    "class Person\n",
    "    attr_accessor :name\n",
    "end\n",
    "\n",
    "d = Person.new; d.name = \"david\"\n",
    "j = Person.new; j.name = \"joe\"\n",
    "r = Person.new; r.name = \"ruby\"\n",
    "\n",
    "module Secretive\n",
    "    def name\n",
    "        \"anonymous\"\n",
    "    end\n",
    "end\n",
    "\n",
    "class << r\n",
    "    include Secretive\n",
    "end\n",
    "\n",
    "puts \"#{d.name}\"; puts \"#{j.name}\"; puts \"#{r.name}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[#<Class:#<String:0x000055764659d988>>, ActiveSupport::ToJsonWithActiveSupportEncoder, String, JSON::Ext::Generator::GeneratorMethods::String, Comparable, ActiveSupport::ToJsonWithActiveSupportEncoder, Object, ActiveSupport::Tryable, PP::ObjectMixin, JSON::Ext::Generator::GeneratorMethods::Object, Kernel, BasicObject]\n"
     ]
    }
   ],
   "source": [
    "# singleton_class method - refers directly to singleton class of an object\n",
    "str = \"a string\"; puts str.singleton_class.ancestors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "singleton method defined on C.\n",
      "singleton method defined on C.\n"
     ]
    }
   ],
   "source": [
    "# class methods, advanced\n",
    "# singleton methods defined on an object == no other object can be a receiver\n",
    "# singleton methods defined on a class == can be called on its subclasses too.\n",
    "\n",
    "class C \n",
    "end\n",
    "def C.a_class_method\n",
    "    puts \"singleton method defined on C.\"\n",
    "end\n",
    "C.a_class_method\n",
    "\n",
    "class D<C\n",
    "end\n",
    "D.a_class_method\n",
    "\n",
    "# singleton classes of class objects sometimes called \"meta classes\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modifying Ruby core classes & modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# risks - changes to Ruby core classes are GLOBAL.\n",
    "# example candidate for ad-hoc changes: Regexp\n",
    "# default: match fail ==> nil; match success ==> MatchData object\n",
    "# nil has no [] method, so [1] ==> NoMethodError\n",
    "# first try:\n",
    "\n",
    "class Regexp\n",
    "    alias __oldmatch__ match\n",
    "    def match(str)\n",
    "        __oldmatch__(str) || []\n",
    "    end\n",
    "end\n",
    "\n",
    "# test it out:\n",
    "/abc/.match(\"X\")[1] # failure won't blow up\n",
    "\n",
    "# problem is, empty arrays interpreted as true. screws up dependent code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hEllo thErE\n",
      "hEllo thErE"
     ]
    }
   ],
   "source": [
    "# another example of risk: String#gsub!\n",
    "str = \"hello there\"\n",
    "print(str.gsub!(/e/,\"E\")+\"\\n\")\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello there"
     ]
    }
   ],
   "source": [
    "# but when gsub! doesn't make any changes: gsub! return value is nil...\n",
    "str = \"hello there\"\n",
    "print(str.gsub!(/zzz/,\"xxx\"))\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"olleH\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tap - executes a code block, yields receiver to block, returns receiver.\n",
    "\"Hello\".tap {|str| puts str.upcase}.reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "peopleLittle Dorritt"
     ]
    }
   ],
   "source": [
    "# changing core functionality safely: technique #1 (additive changes)\n",
    "# (adding a method that doesn't exist)\n",
    "# good example: Active Support\n",
    "require 'active_support'\n",
    "require 'active_support/core_ext'\n",
    "print(\"person\".pluralize)\n",
    "print(\"little_dorritt\".titleize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reversing a string!divad"
     ]
    }
   ],
   "source": [
    "# changing core functionality safely: technique #1 (pass-through overrides)\n",
    "# original version of method gets called along with new version\n",
    "# good for logging & debugging\n",
    "class String\n",
    "    alias __oldreverse__ reverse\n",
    "    def reverse\n",
    "        print(\"reversing a string!\")\n",
    "        __oldreverse__\n",
    "    end\n",
    "end\n",
    "print(\"david\".reverse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-09-21 19:42:15 -05002020-09-21 19:42:15"
     ]
    }
   ],
   "source": [
    "# changing core functionality safely: technique #1a (additive/pass-through)\n",
    "# Active Support does this - example is to_s\n",
    "print(Time.now.to_s)\n",
    "print(Time.now.to_s(:db))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not available\n",
      "joe\n",
      "not available\n"
     ]
    }
   ],
   "source": [
    "# changing core functionality safely: technique #2 (per-object changes with extend)\n",
    "module Secretive\n",
    "    def name\n",
    "        \"not available\"\n",
    "    end\n",
    "end\n",
    "class Person\n",
    "    attr_accessor :name\n",
    "end\n",
    "\n",
    "# extend adds Secretive to lookup paths of individual objects by mixing it into \n",
    "# their singleton classes.\n",
    "\n",
    "david = Person.new; david.name = \"david\"; david.extend(Secretive)\n",
    "joe   = Person.new;   joe.name = \"joe\"\n",
    "ruby  = Person.new;  ruby.name = \"ruby\";   ruby.extend(Secretive)\n",
    "puts \"#{david.name}\"\n",
    "puts \"#{joe.name}\"\n",
    "puts \"#{ruby.name}\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "announcing DAVID!!!\n"
     ]
    }
   ],
   "source": [
    "# changing core functionality safely: technique #3 (refinements)\n",
    "# make a temporary, limited-scope change\n",
    "module Shout\n",
    "    refine String do \n",
    "        def shout\n",
    "            self.upcase+\"!!!\"\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "# refine: takes class name & code block that defines \"refined\" behaviors.\n",
    "# using: target class adopts the new behaviors.\n",
    "\n",
    "class Person\n",
    "    attr_accessor :name\n",
    "    using Shout\n",
    "    def announce\n",
    "        puts \"announcing #{name.shout}\"\n",
    "    end\n",
    "end\n",
    "david = Person.new; david.name = \"David\"; david.announce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### BasicObject\n",
    "- enables you to create \"do nothing\" objects - you can teach them to do anything\n",
    "- typically this means heavy use of _method_missing_.\n",
    "- best example: _Builder_ library for XML writing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BasicObject"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# BasicObject = top of Ruby class tree.\n",
    "String.ancestors.last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:!, :!=, :==, :__binding__, :__id__, :__send__, :equal?, :instance_eval, :instance_exec]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# BO is a class & behaves like one.\n",
    "BasicObject.instance_methods(false).sort"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<IO:<STDOUT>>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# usage (output *should* be XML; NEEDS DEBUG IN JUPYTER CONTEXT.)\n",
    "require 'builder'\n",
    "xml = Builder::XmlMarkup.new(target: STDOUT, indent: 2)\n",
    "xml.instruct! # tells XML to start with XML declaration\n",
    "xml.friends do \n",
    "    xml.friend(source: \"career\") do \n",
    "        xml.name(\"joe\")\n",
    "        xml.address do \n",
    "            xml.street(\"123 main st\")\n",
    "            xml.city(\"anywhere usa 00000\")\n",
    "        end\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "groceries:\n",
      "  name:\n",
      "    apples \n",
      "  qty:\n",
      "    10\n",
      "  name:\n",
      "    sugar\n",
      "  qty:\n",
      "    1 lb\n",
      "  \n",
      "freeze:\n",
      "  name:\n",
      "    ice cream\n",
      "  \n",
      "inspect:\n",
      "  itm:\n",
      "    car\n",
      "  \n",
      "sleep:\n",
      "  hours:\n",
      "    8\n",
      "  \n",
      "print:\n",
      "  book:\n",
      "    ch 13\n",
      "  letter:\n",
      "    to editor\n",
      "  \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# subclass of BasicObject\n",
    "# Lister -- redefines method_missing\n",
    "class Lister<BasicObject\n",
    "    attr_reader :list\n",
    "    def initialize\n",
    "        @list = \"\"; @level = 0\n",
    "    end\n",
    "    def indent(str)\n",
    "        \" \" * @level + str.to_s\n",
    "    end\n",
    "    def method_missing(m, &block)\n",
    "        @list  << indent(m) + \":\" + \"\\n\"\n",
    "        @level += 2\n",
    "        @list  << indent(yield(self)) if block \n",
    "        @level -= 2\n",
    "        @list  << \"\\n\"\n",
    "        return \"\"\n",
    "    end\n",
    "end\n",
    "\n",
    "lister = Lister.new\n",
    "lister.groceries do |item|\n",
    "    item.name { \"apples \"}\n",
    "    item.qty  { 10       }\n",
    "    item.name { \"sugar\"  }\n",
    "    item.qty  { \"1 lb\"   }\n",
    "end\n",
    "lister.freeze do |f|\n",
    "    f.name { \"ice cream\" }\n",
    "end\n",
    "lister.inspect do |i|\n",
    "    i.itm { \"car\" }\n",
    "end\n",
    "lister.sleep do |s|\n",
    "    s.hours { 8 }\n",
    "end\n",
    "lister.print do |doc|\n",
    "    doc.book { \"ch 13\" }\n",
    "    doc.letter { \"to editor\" }\n",
    "end\n",
    "puts lister.list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.7.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}