03-ruby-syntax/03.10-ruby-meta-programming.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ruby 元编程技巧\n",
    "\n",
    "（摘自ruby元编程原书附录）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 常见惯用法\n",
    "\n",
    "### A.1 拟态方法（Mimic Methods）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,world!\n"
     ]
    }
   ],
   "source": [
    "puts \"Hello,world!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的 `puts` 实际上是个方法，完整写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,world!\n"
     ]
    }
   ],
   "source": [
    "puts(\"Hello,world!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "去掉括号的写法使得它像个关键字，同时也更为简洁，因此称之为拟态方法。\n",
    "\n",
    "属性的问题："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"some value\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C\n",
    "    def my_attr=(value)\n",
    "        @p = value\n",
    "    end\n",
    "    def my_attr\n",
    "        @p\n",
    "    end\n",
    "end\n",
    "obj = C.new\n",
    "obj.my_attr = 'some value'\n",
    "obj.my_attr         # => 'some value'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "代码`obj.my_attr = 'some value'`的功能与代码`obj.my_attr=('some value')`的功能是相同的，不过前者看起来更清爽。\n",
    "\n",
    "来自 Camping 的例子，这里的 `R` 实际上是一个方法，`'/help'` 是它的参数，返回值是一个 `Class` 的实例。\n",
    "\n",
    "```ruby\n",
    "class Help < R '/help'\n",
    "    def get\n",
    "        # rendering for HTTP GET...\n",
    "    end\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A.2 空指针保护（Nil Guards）\n",
    "\n",
    "```ruby\n",
    "a ||= []\n",
    "```\n",
    "\n",
    "以上代码等价于\n",
    "\n",
    "```ruby\n",
    "a = a || []\n",
    "```\n",
    "\n",
    "空指针保护常用于初始化实例变量，看看下面这个类：\n",
    "\n",
    "```ruby\n",
    "class C\n",
    "    def initialize(value)\n",
    "        @a = []\n",
    "    end\n",
    "    def elements\n",
    "        @a\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "使用空指针保护，可以更简练地重写以上这段代码：\n",
    "\n",
    "```ruby\n",
    "class C\n",
    "    def elements\n",
    "        @a ||= []\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "上面的代码会在最后它要被访问的时候才进行初始化，这种惯用法被称为**惰性实例变量(Lazy Instance Variable)**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A.3 关于方法参数的技巧（Tricks with Method Arguments）\n",
    "\n",
    "\n",
    "#### 具名参数(Named Arguments)\n",
    "\n",
    "当在Ruby中调用方法时，你不得不按照特定的顺序输入参数。如果顺序错误，则会引入一个bug：\n",
    "\n",
    "```ruby\n",
    "def login(name, password, message)\n",
    "    # DO LOGIN\n",
    "end\n",
    "login('james', 'just doing some administration', '123456')\n",
    "```\n",
    "\n",
    "当有一大串参数要输入时，这种错误非常常见。\n",
    "\n",
    "Ruby 2.0 以后，可以使用关键字参数，Ruby 2.0可以使用Hash参数来解决这个问题。\n",
    "\n",
    "```ruby\n",
    "login(name: 'bill', message: 'just doing some administration', password: '123456')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 参数数组和默认值(Argument Arrays and Default Values)\n",
    "\n",
    "*操作符可以把多个参数收集到一个数组中*；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, \"2\", \"three\"]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_method(*args)\n",
    "    args\n",
    "end\n",
    "\n",
    "my_method(1, '2' , 'three')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ruby 也支持如下参数默认值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a value and a default value\""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_method(x, y = \"a default value\" )\n",
    "    \"#{x} and #{y}\"\n",
    "end\n",
    "my_method(\"a value\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 混合使用参数的惯用法(Mixing Arguments Idioms)\n",
    "\n",
    "Ruby 2.0以前\n",
    "\n",
    "```ruby\n",
    "def my_method(arg, hash)\n",
    "  lots = hash[:lots] || \"default\"\n",
    "  args = hash[:args] || \"another\"\n",
    "  hand = hash[:by_hand] || \"annoying\"\n",
    "  ...\n",
    "end\n",
    "my_method \"with\", lots: \"of\", args: \"in\", by_hand: \"form\"\n",
    "```\n",
    "\n",
    "Ruby 2.0以后\n",
    "\n",
    "```ruby\n",
    "def my_method(arg, lots: \"default\", args: \"another\", by_hand: \"annoying\")\n",
    "  lots = hash[:lots] || \"default\"\n",
    "  args = hash[:args] || \"another\"\n",
    "  hand = hash[:by_hand] || \"annoying\"\n",
    "  ...\n",
    "end\n",
    "my_method \"with\", lots: \"of\", args: \"in\", by_hand: \"form\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A.4 Self Yield\n",
    "\n",
    "当给方法传入一个块时，你会期望这个方法通过`yield`对块进行回调。这种回调有一种有用的变形，就是对象可以把自身传给这个块。下面的例子来自于RubyGems包管理器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 传统写法\n",
    "\n",
    "```ruby\n",
    "spec = Gem::Specification.new\n",
    "spec.name = \"My Gem name\"\n",
    "spec.version = \"0.0.1\"\n",
    "# ...\n",
    "```\n",
    "\n",
    "#### Self Yield 写法\n",
    "\n",
    "```ruby\n",
    "spec = Gem::Specification.new do |s|\n",
    "    s.name = \"My Gem name\"\n",
    "    s.version = \"0.0.1\"\n",
    "    # ...\n",
    "end\n",
    "```\n",
    "\n",
    "\n",
    "#### Gem::Specification 源代码\n",
    "\n",
    "```ruby\n",
    "module Gem\n",
    "    class Specification\n",
    "        def initialize\n",
    "            yield self if block_given?\n",
    "            # ...\n",
    "        end\n",
    "        #...\n",
    "    end\n",
    "end\n",
    "```\n",
    "\n",
    "#### 来自 tap() 的例子\n",
    "\n",
    "在Ruby中，长长的方法调用链很普遍\n",
    "\n",
    "```ruby\n",
    "['a', 'b', 'c'].push('d').shift.upcase.next # => \"B\"\n",
    "```\n",
    "\n",
    "但是某一步出错，你将不得不如下调试\n",
    "\n",
    "```ruby\n",
    "temp = ['a' , 'b' , 'c' ].push('d').shift\n",
    "puts temp\n",
    "x = temp.upcase.next\n",
    "```\n",
    "\n",
    "这非常笨拙；Ruby 1.9 中引入了 tap() 方法，我们可以这样做\n",
    "\n",
    "```ruby\n",
    "['a' , 'b' , 'c' ].push('d' ).shift.tap{|x| puts x}.upcase.next\n",
    "```\n",
    "\n",
    "老版本的 Ruby ，我们也可以很容易的实现一个\n",
    "\n",
    "```ruby\n",
    "class Object\n",
    "    def tap\n",
    "        yield self\n",
    "        self\n",
    "    end\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A.5 Symbol#to_proc() 方法\n",
    "\n",
    "这种有点诡异的法术在Ruby程序员中很流行，请看下面的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Bob\", \"Bill\", \"Heather\"]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['bob' , 'bill' , 'heather' ]\n",
    "names.map {|name| name.capitalize}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更简洁的写法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"Bob\", \"Bill\", \"Heather\"]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = ['bob' , 'bill' , 'heather' ]\n",
    "names.map(&:capitalize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当`&`操作符作用于一个对象时，它会调用该对象的`to_proc`方法，将其转化为一个`proc`对象。\n",
    "\n",
    "```ruby\n",
    "class Symbol\n",
    "    def to_proc\n",
    "        Proc.new {|x| x.send(self) }\n",
    "    end\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 法术手册"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 法术集 (The Spells)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 数组参数(Argument Array)\n",
    "\n",
    "把一组参数压入到一个数组中。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[\"cba\", \"zyx\", \"321\"]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_method(*args)\n",
    "    args.map {|arg| arg.reverse }\n",
    "end\n",
    "\n",
    "my_method('abc' , 'xyz' , '123')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 环绕别名(Around Alias)\n",
    "\n",
    "从一个重新定义的方法中调用原始的、被重命名的版本。\n",
    "\n",
    "三个基本步骤：\n",
    "    1. 通过 alias 对原有方法定义一个别名\n",
    "    2. 覆写原有方法\n",
    "    3. 在该方法中调用别名方法\n",
    "\n",
    "通过此方式可以改写原来方法，又不破坏原有功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"xcbax\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class String\n",
    "    alias :old_reverse :reverse\n",
    "    def reverse\n",
    "        \"x#{old_reverse}x\"\n",
    "    end\n",
    "end\n",
    "\n",
    "\"abc\".reverse # => \"xcbax\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class String\n",
    "    alias :reverse :old_reverse\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 白板(Blank Slate)\n",
    "\n",
    "移除一个对象中的所有方法，以便通过 `method_missing` 添加幽灵方法。主要目的避免原有类中的方法同新增方法产生冲突。注意以 `__` 开头的方法不能移除，比如 `__send__` 等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"#<BlankSlate:0x007fa6c836b4a8>\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class BlankSlate\n",
    "    def method_missing(name, *args)\n",
    "        \"a Ghost Method\"\n",
    "    end\n",
    "end\n",
    "\n",
    "obj = BlankSlate.new\n",
    "obj.to_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a Ghost Method\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class BlankSlate\n",
    "    instance_methods.each do |m|\n",
    "        undef_method m unless m.to_s =~ /method_missing|respond_to?|object_id|^__/\n",
    "    end\n",
    "end\n",
    "\n",
    "obj.to_s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类扩展(Class Extension)\n",
    "\n",
    "通过向`eigenclass`中混入模块来定义类方法（是对象扩展的一个特例）。\n",
    "\n",
    "扩展的方法存在于`eigenclass`类中，对类来说就是类方法，对对象实例来说就是单件方法。\n",
    "\n",
    "> 提示：一个类，如`class C`具有双重身份。本身是个类，同时又是`Class`类的一个实例。类混入实际上是针对他作为`Class`类的一个实例对象的身份来进行的。\n",
    "\n",
    "因此类扩展的方式一样适用于对象实例的扩展，那就是对象扩展了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a class method\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C; end\n",
    "\n",
    "module M\n",
    "    def my_method\n",
    "        'a class method'\n",
    "    end\n",
    "end\n",
    "\n",
    "class << C\n",
    "    include M\n",
    "end\n",
    "\n",
    "C.my_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类扩展混入(Class Extension Mixin)\n",
    "\n",
    "使一个模块可以通过钩子方法扩展它的包含者。\n",
    "\n",
    "同上面基本类似，差别主要有：\n",
    "  1. 通过 `extend` 方法，避免手工打开 `eigenclass` (即`class << C; end`)操作。\n",
    "  2. 通过 `included` 钩子方法触发。\n",
    "  3. 可以同时添加实例方法跟类方法（这个例子没有演示）\n",
    "\n",
    "基本编写方式：\n",
    "  1. 定义一个模块，如 `MyMixin`\n",
    "  2. 在 `MyMixin` 中定义一个内部模块，通常叫 `ClassMethods`，并定义一些方法，这些方法会成为包含者的类方法。\n",
    "  3. 覆写 `MyMixin#included()` 方法，`extend ClassMethods`。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a class method\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module M\n",
    "    def self.included(base)\n",
    "        base.extend(ClassMethods)\n",
    "    end\n",
    "\n",
    "    module ClassMethods\n",
    "        def my_method\n",
    "            'a class method'\n",
    "        end\n",
    "    end\n",
    "end\n",
    "\n",
    "class C\n",
    "    include M\n",
    "end\n",
    "C.my_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类实例变量(Class Instance Variable)\n",
    "\n",
    "在一个 Class 对象的实例变量中存储类级别的状态。\n",
    "\n",
    "核心提示：\n",
    "  1. 这里的`class C`要当做`Class`类的一个实例对象看待。普通实例对象如何创建实例变量，类实例对象就如何创建实例变量。\n",
    "  2. `class ... end` 实际上是在运行一段代码，不要用常规的关键字理解。\n",
    "  3. 访问类实例变量，只能通过类方法（因为其 `self` 就是类名），或者加上类名前缀。\n",
    "\n",
    "想一想如果我们运行时类名动态变化，如何处理，显然我们还有 `eval` 工具组（使用 `instance_eval` ，`class_eval`，`eval` 均可）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"some value\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C\n",
    "    @my_class_instance_variable = \"some value\"\n",
    "    def self.class_attribute\n",
    "        @my_class_instance_variable\n",
    "    end\n",
    "end\n",
    "C.class_attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 类宏(Class Macro)\n",
    "\n",
    "在类定义中使用一个类方法。\n",
    "就是一个伪装成关键字的类方法。如`attr_accessor :a, :b`，类宏一般结合类扩展混入技术进行。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"my_macro(x) called\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C; end\n",
    "class << C\n",
    "    def my_macro(arg)\n",
    "        \"my_macro(#{arg}) called\"\n",
    "    end\n",
    "end\n",
    "class C\n",
    "    my_macro :x\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 洁净室(Clean Room)\n",
    "\n",
    "使用对象作为执行块的上下文环境\n",
    "实际上就是通过 `instance_eval` 限定执行块的作用域。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class CleanRoom\n",
    "    def a_useful_method(x); x * 2; end\n",
    "end\n",
    "\n",
    "CleanRoom.new.instance_eval { a_useful_method(3) }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 代码处理器(Code Processor)\n",
    "\n",
    "处理从外部获得的字符串代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing a_file_containing_lines_of_ruby.txt\n"
     ]
    }
   ],
   "source": [
    "%%file a_file_containing_lines_of_ruby.txt\n",
    "1 + 1\n",
    "3 * 2\n",
    "Math.log10(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 1 ==> 2\n",
      "3 * 2 ==> 6\n",
      "Math.log10(100) ==> 2.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"1 + 1\\n\", \"3 * 2\\n\", \"Math.log10(100)\"]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "File.readlines(\"a_file_containing_lines_of_ruby.txt\" ).each do |line|\n",
    "    puts \"#{line.chomp} ==> #{eval(line)}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 上下文探针(Context Probe)\n",
    "\n",
    "执行块来获取对象上下文中的信息。\n",
    "其实就是通过 `instance_eval` 将对象内部的作用域暴露出来。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a private instance variable\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class AClass\n",
    "    def initialize\n",
    "        @x = \"a private instance variable\"\n",
    "    end\n",
    "end\n",
    "obj = AClass.new\n",
    "obj.instance_eval { @x }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 延迟执行(Deferred Evaluation)\n",
    "\n",
    "在 `proc` 或 `lambda` 中存储一段代码及其上下文，用于以后执行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class AClass\n",
    "    def store(&block)\n",
    "        @my_code_capsule = block\n",
    "    end\n",
    "    def execute\n",
    "        @my_code_capsule.call\n",
    "    end\n",
    "end\n",
    "\n",
    "obj = AClass.new\n",
    "obj.store { $X = 1 }\n",
    "$X = 0\n",
    "obj.execute\n",
    "$X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### 动态派发(Dynamic Dispatcher)\n",
    "\n",
    "在运行时决定调用哪个方法\n",
    "通过 `send` 发送消息，等价于方法调用。但通过 `send` 可以发送符号或字符串，灵活性大为增强。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"ABC\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "method_to_call = :upcase\n",
    "obj = \"abc\"\n",
    "obj.send(method_to_call)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 动态方法(Dynamic Method)\n",
    "\n",
    "在运行时才决定如何定义一个方法\n",
    "动态方法还有一个特性：不会开启一个新的作用域。\n",
    "我们知道`def`，`module`，`class`会开启新的作用域，扁平化作用域的办法就是用`define_method`，`Module.new`，`Class.new`等方法调用取代关键字。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a dynamic method\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class AClass\n",
    "end\n",
    "\n",
    "AClass.class_eval do\n",
    "    define_method :my_method do\n",
    "        \"a dynamic method\"\n",
    "    end\n",
    "end\n",
    "obj = AClass.new\n",
    "obj.my_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 动态代理(Dynamic Proxy)\n",
    "\n",
    "把不能对应某个方法名的消息转发给另外一个对象。\n",
    "`method_missing` 结合 `send` 技术，另外可以辅助 `respond_to?` 谓词。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"result: gnirts a\""
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class MyDynamicProxy\n",
    "    def initialize(target)\n",
    "        @target = target\n",
    "    end\n",
    "    def method_missing(name, *args, &block)\n",
    "        \"result: #{@target.send(name, *args, &block)}\"\n",
    "    end\n",
    "end\n",
    "obj = MyDynamicProxy.new(\"a string\")\n",
    "obj.reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 扁平作用域(Flat Scope)\n",
    "\n",
    "使用闭包在两个作用域之间共享变量(以下用例不典型)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C\n",
    "    def an_attribute\n",
    "        @attr\n",
    "    end\n",
    "end\n",
    "obj = C.new\n",
    "a_variable = 100\n",
    "\n",
    "# flatscope:\n",
    "obj.instance_eval do\n",
    "    @attr = a_variable\n",
    "end\n",
    "\n",
    "obj.an_attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 幽灵方法(Ghost Method)\n",
    "\n",
    "响应一个没有关联方法的消息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"dohtem_tsohg_ym\""
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C\n",
    "    def method_missing(name, *args)\n",
    "        name.to_s.reverse\n",
    "    end\n",
    "end\n",
    "obj = C.new\n",
    "obj.my_ghost_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 钩子方法(Hook Method)\n",
    "\n",
    "通过覆写某个特殊方法来截获对象模型事件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[D, E, F]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "$INHERITORS = []\n",
    "class C\n",
    "    def self.inherited(subclass)\n",
    "        $INHERITORS << subclass\n",
    "    end\n",
    "end\n",
    "class D < C\n",
    "end\n",
    "\n",
    "class E < C\n",
    "end\n",
    "\n",
    "class F < E\n",
    "end\n",
    "\n",
    "$INHERITORS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 内核方法(Kernal Method)\n",
    "在 `Kernel` 模块中定义一个方法，使之对所有对象都可用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a kernel method\""
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module Kernel\n",
    "    def a_method\n",
    "        \"a kernel method\"\n",
    "    end\n",
    "end\n",
    "a_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 惰性实例变量(Lazy Instance Variable)\n",
    "\n",
    "当第一次访问一个实例变量时才对之进行初始化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"some value\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class C\n",
    "    def attribute\n",
    "        @attribute ||= \"some value\"\n",
    "    end\n",
    "end\n",
    "\n",
    "obj = C.new\n",
    "obj.attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 拟态方法(Mimic Method)\n",
    "把一个方法伪装成另外一种语言构件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def BaseClass(name)\n",
    "    name == \"string\" ? String : Object\n",
    "end\n",
    "class SubClass < BaseClass \"string\" # a method that looks like a class\n",
    "    attr_accessor :an_attribute # 伪装成关键字的方法\n",
    "end\n",
    "\n",
    "obj = SubClass.new\n",
    "obj.an_attribute = 1 # 伪装成属性的方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 猴子打补丁(Monkeypatch)\n",
    "\n",
    "修改已有类的特性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cba\n",
      "override\n"
     ]
    }
   ],
   "source": [
    "puts \"abc\".reverse\n",
    "\n",
    "class String\n",
    "    def reverse\n",
    "        \"override\"\n",
    "    end\n",
    "end\n",
    "\n",
    "puts \"abc\".reverse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 有名参数(Named Arguments)\n",
    "把方法参数收集到一个哈希表中，以便通过名字访问（Ruby2.0+直接支持）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"B\""
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_method(args)\n",
    "    args[:arg2]\n",
    "end\n",
    "\n",
    "my_method(:arg1 => \"A\" , :arg2 => \"B\" , :arg3 => \"C\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 命名空间(Namespace)\n",
    "\n",
    "在一个模块中定义常量，以防止命名冲突。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "my class\n"
     ]
    }
   ],
   "source": [
    "module MyNamespace\n",
    "    class Array\n",
    "        def to_s\n",
    "            \"my class\"\n",
    "        end\n",
    "    end\n",
    "end\n",
    "puts Array.new\n",
    "puts MyNamespace::Array.new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 空指针保护(Nil Guard)\n",
    "\n",
    "用“或”操作符覆写一个空应用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a value\""
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = nil\n",
    "y = x || \"a value\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 对象扩展(Object Extension)\n",
    "\n",
    "通过给一个对象 `eigenclass` 混入模块来定义单件方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"a singleton method\""
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = Object.new\n",
    "\n",
    "module M\n",
    "    def my_method\n",
    "        'a singleton method'\n",
    "    end\n",
    "end\n",
    "\n",
    "class << obj\n",
    "    include M\n",
    "end\n",
    "\n",
    "obj.my_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 打开类(Open Class)\n",
    "\n",
    "修改已有的类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"my method\""
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class String\n",
    "    def my_string_method\n",
    "        \"my method\"\n",
    "    end\n",
    "end\n",
    "\n",
    "\"abc\".my_string_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 模式派发(Pattern Dispatch)\n",
    "\n",
    "根据名字来选择需要调用的方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "$x = 0\n",
    "\n",
    "class BClass\n",
    "    def my_first_method\n",
    "        $x += 1\n",
    "    end\n",
    "    def my_second_method\n",
    "        $x += 2\n",
    "    end\n",
    "end\n",
    "\n",
    "obj = BClass.new\n",
    "obj.methods.each do |m|\n",
    "    puts obj.send(m) if m.to_s =~ /^my_/\n",
    "end\n",
    "\n",
    "$x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 沙盒(Sandbox)\n",
    "\n",
    "在一个安全的环境中执行为授信的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File.read('sandbox_ruby_codes.txt').tainted? = true\n",
      "'Hello World'.tainted? = false\n",
      "Hello World!\n",
      "168\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "#<SecurityError: Insecure operation - eval>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sandbox(&code)\n",
    "  lambda{\n",
    "    $SAFE = 1\n",
    "    eval(yield.to_s, code.binding) \n",
    "  }.call\n",
    "end\n",
    "\n",
    "code_str =<<-RUBY\n",
    "puts \"Hello World!\"\n",
    "puts 5 ** 3 + 4 * 9 + 7 \n",
    "RUBY\n",
    "\n",
    "File.write \"sandbox_ruby_codes.txt\", code_str\n",
    "\n",
    "puts \"File.read('sandbox_ruby_codes.txt').tainted? = #{File.read('sandbox_ruby_codes.txt').tainted?}\"\n",
    "puts \"'Hello World'.tainted? = #{'Hello World'.tainted?}\"\n",
    "\n",
    "begin\n",
    "  sandbox{ code_str }  \n",
    "  sandbox{ File.read('sandbox_ruby_codes.txt') }\n",
    "rescue Exception => ex\n",
    "  ex\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 作用域门(Scope Gate)\n",
    "\n",
    "用 `class`，`module` 或 `def` 关键字来隔离作用域"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"local-variable\"\n",
      "nil\n",
      "\"local-variable\"\n",
      "\"local-variable\"\n",
      "nil\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "p defined? a\n",
    "\n",
    "module MyModule\n",
    "    b = 1\n",
    "    p defined? a\n",
    "    p defined? b\n",
    "end\n",
    "\n",
    "p defined? a\n",
    "p defined? b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Self Yield\n",
    "\n",
    "把 `self` 传给当前块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Person:0x007fa6c933a410 @name=\"Joe\", @surname=\"Smith\">"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person\n",
    "    attr_accessor :name, :surname\n",
    "    def initialize\n",
    "        yield self\n",
    "    end\n",
    "end\n",
    "\n",
    "joe = Person.new do |p|\n",
    "    p.name = 'Joe'\n",
    "    p.surname = 'Smith'\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 共享作用域(Shared Scope)\n",
    "\n",
    "在同一个扁平作用域的多个上下文中共享变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "lambda {\n",
    "    shared = 10\n",
    "    self.class.class_eval do\n",
    "        define_method :counter do\n",
    "            shared\n",
    "        end\n",
    "        define_method :down do\n",
    "            shared -= 1\n",
    "        end\n",
    "    end\n",
    "}.call\n",
    "\n",
    "puts counter\n",
    "3.times { down }\n",
    "puts counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 单件方法(Singleton Method)\n",
    "\n",
    "在一个对象上定义一个方法，其实是在该对象 `eigenclass` 中定义了一个实例方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"x\""
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj = \"abc\"\n",
    "\n",
    "class << obj\n",
    "    def my_singleton_method\n",
    "        \"x\"\n",
    "    end\n",
    "end\n",
    "obj.my_singleton_method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 代码字符串(String of Code)\n",
    "\n",
    "执行一段表示 Ruby 代码的字符串。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_string_of_code = \"1 + 1\"\n",
    "eval(my_string_of_code)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### 符号到Proc(Symbol To Proc)\n",
    "\n",
    "把一个符号转换为调用单个方法的代码块。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[false, true, false, true]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3, 4].map(&:even?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "File.delete 'a_file_containing_lines_of_ruby.txt', 'sandbox_ruby_codes.txt'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.4.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}