И.В. Симдянов "Самоучитель Ruby" [+code] (2020) [PDF]

[nulled]

Автор: И.В. Симдянов
Издательство: БХВ-Петербург
Серия: Самоучитель
Жанр: Компьютерная литература
Формат: PDF
Качество: Изначально электронное (ebook)
Иллюстрации: Черно-белые

ОПИСАНИЕ:
Язык Ruby излагается последовательно от простого к сложному. Описываются интерпретатор Ruby, утилиты, детально рассматривается современная Ruby-экосистема, работа со стандартной и сторонними библиотеками. Дан разбор синтаксических конструкций: операторов, переменных, констант, конструкций ветвления и циклов, блоков и итераторов. Подробно описаны объектно-ориентированные возможности Ruby: классы, модули, объекты и методы. Показано практическое применение языка Ruby в веб-программировании и автоматическом тестировании. Для закрепления материала в конце глав приводятся задания. С помощью книги можно не только освоить язык Ruby, но и подготовиться к работе с профессиональными фреймворками: Ruby on Rails, Sinatra, RSpec, MiniTest и Cucumber. Опытных разработчиков может заинтересовать подробное описание нововведений версий от 2.0 до 2.6. Электронный архив с исходными кодами доступен на сайте издательства и GitHub

 

ОГЛАВЛЕНИЕ:

Спойлер

Оглавление
Предисловие ................................................................................................................... 13
Цель книги ...................................................................................................................................... 13
Как создавалась книга... ................................................................................................................ 13
Терминология ................................................................................................................................ 14
Исходные коды .............................................................................................................................. 14
Задания ........................................................................................................................................... 15
Типографские соглашения ............................................................................................................ 15
Благодарности ................................................................................................................................ 16
Глава 1. Введение в язык Ruby .................................................................................. 19
1.1. Философия Ruby ..................................................................................................................... 19
1.2. Реализации Ruby ..................................................................................................................... 21
1.3. Версии...................................................................................................................................... 23
1.4. Установка Ruby ....................................................................................................................... 24
1.4.1. Установка Ruby в Windows ......................................................................................... 24
1.4.2. Установка Ruby в Linux (Ubuntu) ................................................................................ 26
1.4.2.1. Менеджер версий RVM .................................................................................. 26
1.4.2.2. Менеджер версий rbenv .................................................................................. 28
1.4.3. Установка Ruby в macOS ............................................................................................. 29
1.5. Запуск программы на выполнение ........................................................................................ 30
Задания ........................................................................................................................................... 31
Глава 2. Быстрый старт ............................................................................................... 33
2.1. Соглашения Ruby .................................................................................................................... 33
2.2. Комментарии ........................................................................................................................... 34
2.3. Элементы языка ...................................................................................................................... 35
2.3.1. Ключевые слова ........................................................................................................... 36
2.3.2. Переменные .................................................................................................................. 37
2.3.3. Константы ..................................................................................................................... 37
2.3.4. Объекты ........................................................................................................................ 38
2.3.5. Классы и модули .......................................................................................................... 39
2.3.6. Методы .......................................................................................................................... 40
2.3.7. Операторы..................................................................................................................... 40
4 Оглавление
2.4. Вывод в стандартный поток .................................................................................................. 41
2.4.1. Вывод при помощи методов puts и p .......................................................................... 41
2.4.2. Экранирование ............................................................................................................. 42
2.5. Как пользоваться документацией? ........................................................................................ 43
2.5.1. Справочные методы объектов ..................................................................................... 44
2.5.2. Консольная справка ..................................................................................................... 45
2.5.3. Online-документация .................................................................................................... 46
Задания ........................................................................................................................................... 46
Глава 3. Утилиты и гемы ............................................................................................ 47
3.1. Утилиты ................................................................................................................................... 47
3.2. Интерактивный Ruby .............................................................................................................. 48
3.3. Шаблонизатор erb ................................................................................................................... 50
3.4. Утилита rake ............................................................................................................................ 50
3.5. Утилита rdoc ........................................................................................................................... 53
3.6. Гемы ......................................................................................................................................... 54
3.6.1. Отладка программ при помощи гема pry ................................................................... 56
3.6.2. Контроль стиля кода при помощи гема rubocop ....................................................... 57
3.6.3. Управление гемами при помощи bundler ................................................................... 58
Задания ........................................................................................................................................... 63
Глава 4. Предопределенные классы .......................................................................... 65
4.1. Синтаксические конструкторы .............................................................................................. 65
4.2. Строки. Класс String ............................................................................................................... 67
4.2.1. Синтаксические конструкторы %q и %Q ................................................................... 67
4.2.2. Heredoc-оператор ......................................................................................................... 68
4.2.3. Выполнение команд операционной системы............................................................. 69
4.2.4. Устройство строки ....................................................................................................... 70
4.2.5. Обработка подстрок ..................................................................................................... 71
4.3. Символы. Класс Symbol .......................................................................................................... 73
4.4. Целые числа. Класс Integer .................................................................................................... 74
4.5. Вещественные числа. Класс Float ......................................................................................... 76
4.6. Диапазоны. Класс Range ........................................................................................................ 79
4.7. Массивы. Класс Array ............................................................................................................ 81
4.7.1. Создание массива ......................................................................................................... 81
4.7.2. Операции с массивами ................................................................................................. 81
4.7.3. Синтаксические конструкторы %w и %i .................................................................... 82
4.8. Хэши. Класс Hash ................................................................................................................... 83
4.9. Логические объекты true и false ............................................................................................ 84
4.10. Объект nil .............................................................................................................................. 85
Задания ........................................................................................................................................... 85
Глава 5. Переменные .................................................................................................... 87
5.1. Типы переменных ................................................................................................................... 87
5.1.1. Локальные переменные ............................................................................................... 87
5.1.2. Глобальные переменные .............................................................................................. 89
5.1.2.1. Предопределенная переменная $LOAD_PATH ............................................ 91
5.1.2.2. Предопределенная переменная $stdout ......................................................... 91
5.1.2.3. Предопределенная переменная $PROGRAM_NAME ................................... 92
Оглавление 5
5.1.3. Инстанс-переменные.................................................................................................... 93
5.1.4. Переменные класса ...................................................................................................... 96
5.2. Присваивание .......................................................................................................................... 97
5.3. Клонирование .......................................................................................................................... 99
Задания ......................................................................................................................................... 101
Глава 6. Константы ..................................................................................................... 103
6.1. Создание и определение констант ....................................................................................... 103
6.2. Предопределенные константы ............................................................................................. 104
6.3. Ключевые слова __LINE__ и __FILE__ .............................................................................. 107
6.4. Метод require ........................................................................................................................ 107
6.5. Метод require_relative .......................................................................................................... 109
6.6. Подключение стандартных классов .................................................................................... 110
6.7. Подключение гемов .............................................................................................................. 111
Задания ......................................................................................................................................... 113
Глава 7. Операторы .................................................................................................... 115
7.1. Операторы — это методы .................................................................................................... 115
7.2. Арифметические операторы ................................................................................................ 116
7.3. Присваивание ........................................................................................................................ 117
7.3.1. Сокращенная форма арифметических операторов ................................................. 117
7.3.2. Параллельное присваивание ..................................................................................... 118
7.3.3. Круглые скобки в параллельном присваивании ...................................................... 119
7.3.4. Оператор * .................................................................................................................. 120
7.4. Операторы строк ................................................................................................................... 122
7.4.1. Умножение строки на число ..................................................................................... 122
7.4.2. Сложение строк .......................................................................................................... 123
7.4.3. Форматирование строк .............................................................................................. 124
7.5. Операторы сравнения ........................................................................................................... 128
7.5.1. Особенности сравнения объектов ............................................................................. 129
7.5.2. Сравнение с нулем ..................................................................................................... 131
7.5.3. Особенности сравнения вещественных чисел ......................................................... 132
7.5.4. Особенности сравнения строк ................................................................................... 132
7.6. Поразрядные операторы ...................................................................................................... 134
7.7. Оператор безопасного вызова ............................................................................................. 138
7.8. Ключевое слово defined? ...................................................................................................... 139
7.9. Приоритет операторов ......................................................................................................... 140
Задания ......................................................................................................................................... 141
Глава 8. Ветвление ...................................................................................................... 143
8.1. Ключевое слово if ................................................................................................................. 143
8.1.1. Ключевые слова else и elsif ........................................................................................ 145
8.1.2. Ключевое слово then .................................................................................................. 146
8.1.3. if-модификатор ........................................................................................................... 147
8.1.4. Присваивание if-результата переменной .................................................................. 148
8.1.5. Присваивание в условии if-оператора ...................................................................... 149
8.2. Логические операторы ......................................................................................................... 150
8.2.1. Логическое И. Оператор && ..................................................................................... 151
8.2.2. Логическое ИЛИ. Оператор || ................................................................................... 151
8.2.3. Логическое отрицание ............................................................................................... 154
6 Оглавление
8.3. Ключевое слово unless.......................................................................................................... 155
8.4. Условный оператор .............................................................................................................. 156
8.5. Ключевое слово case ............................................................................................................ 156
8.6. Советы ................................................................................................................................... 159
Задания ......................................................................................................................................... 161
Глава 9. Глобальные методы .................................................................................... 163
9.1. Создание метода ................................................................................................................... 163
9.2. Параметры и аргументы ....................................................................................................... 164
9.2.1. Значения по умолчанию ............................................................................................ 165
9.2.2. Неограниченное количество параметров ................................................................. 165
9.2.3. Позиционные параметры ........................................................................................... 167
9.2.4. Хэши в качестве параметров ..................................................................................... 167
9.3. Возвращаемое значение ....................................................................................................... 168
9.4. Получатель метода ............................................................................................................... 170
9.5. Псевдонимы методов ........................................................................................................... 172
9.6. Удаление метода ................................................................................................................... 172
9.7. Рекурсивные методы ............................................................................................................ 172
9.8. Предопределенные методы .................................................................................................. 175
9.8.1. Чтение входного потока ............................................................................................ 175
9.8.2. Остановка программы ............................................................................................... 177
9.8.3. Методы-конструкторы ............................................................................................... 179
9.9. Логические методы ............................................................................................................... 180
9.10. bang-методы ........................................................................................................................ 181
Задания ......................................................................................................................................... 182
Глава 10. Циклы .......................................................................................................... 183
10.1. Цикл while............................................................................................................................ 183
10.2. Вложенные циклы .............................................................................................................. 188
10.3. Досрочное прекращение циклов ....................................................................................... 189
10.4. Цикл until ............................................................................................................................. 191
10.5. Цикл for ............................................................................................................................... 192
Задания ......................................................................................................................................... 193
Глава 11. Итераторы................................................................................................... 195
11.1. Итераторы и блоки ............................................................................................................. 195
11.2. Обход итераторами массивов и хэшей ............................................................................. 196
11.3. Итератор times ..................................................................................................................... 197
11.4. Итераторы upto и downto.................................................................................................... 198
11.5. Итераторы коллекций ......................................................................................................... 198
11.5.1. Итератор each ......................................................................................................... 199
11.5.2. Итератор each_with_index ...................................................................................... 200
11.5.3. Итератор map .......................................................................................................... 200
11.5.4. Итераторы select и reject ........................................................................................ 201
11.5.5. Итератор reduce ...................................................................................................... 203
11.5.6. Итератор each_with_object ..................................................................................... 204
11.6. Итератор tap ........................................................................................................................ 205
11.7. Сокращенная форма итераторов ....................................................................................... 207
Оглавление 7
11.8. Досрочное прекращение итерации .................................................................................... 207
11.9. Класс Enumerator ................................................................................................................ 209
Задания ......................................................................................................................................... 210
Глава 12. Блоки ........................................................................................................... 211
12.1. Блоки в собственных методах ........................................................................................... 211
12.2. Передача значений в блок .................................................................................................. 213
12.3. Метод block_given? ............................................................................................................. 215
12.4. Возврат значений из блока ................................................................................................. 215
12.5. Итератор yield_self .............................................................................................................. 216
12.6. Передача блока через параметр ......................................................................................... 217
12.7. Различие { ... } и do ... end .................................................................................................. 219
12.8. Блоки в рекурсивных методах ........................................................................................... 221
12.9. Класс Proc ........................................................................................................................... 225
12.10. Методы proc и lambda ...................................................................................................... 226
12.11. Различия proc и lambda .................................................................................................... 227
Задания ......................................................................................................................................... 230
Глава 13. Классы ......................................................................................................... 231
13.1. Создание класса .................................................................................................................. 231
13.2. Класс — это объект ............................................................................................................ 232
13.3. Как проектировать классы? ............................................................................................... 234
13.4. Переопределение методов ................................................................................................. 234
13.5. Открытие класса ................................................................................................................. 235
13.6. Тело класса и его свойства................................................................................................. 237
13.7. Вложенные классы ............................................................................................................. 238
13.8. Константы ........................................................................................................................... 240
13.9. Переменные класса ............................................................................................................. 241
Задания ......................................................................................................................................... 243
Глава 14. Методы в классах ...................................................................................... 245
14.1. Сохранение состояния в объекте ....................................................................................... 245
14.2. Установка начального состояния объекта ........................................................................ 246
14.2.1. Метод initialize ........................................................................................................ 247
14.2.2. Параметры метода new........................................................................................... 250
14.2.3. Блоки в методе new ................................................................................................ 254
14.2.4. Метод initialize и переменные класса ................................................................... 255
14.2.5. Как устроен метод new? ......................................................................................... 255
14.3. Специальные методы присваивания ................................................................................. 256
14.3.1. Методы со знаком равенства (=) в конце имени ................................................. 257
14.3.2. Аксессоры ............................................................................................................... 259
14.4. Синглетон-методы .............................................................................................................. 261
14.5. Методы класса .................................................................................................................... 264
14.6. Обработка несуществующих методов .............................................................................. 266
14.6.1. Создание метода define_method ............................................................................. 267
14.6.2. Перехват вызовов несуществующих методов ...................................................... 268
14.7. Метод send ........................................................................................................................... 270
Задания ......................................................................................................................................... 275
8 Оглавление
Глава 15. Преобразование объектов ........................................................................ 277
15.1. Сложение строк и чисел ..................................................................................................... 277
15.2. Методы преобразования объектов .................................................................................... 278
15.3. Сложение объектов ............................................................................................................. 282
15.4. Сложение объекта и числа ................................................................................................. 283
15.5. Сложение объекта и строки ............................................................................................... 286
15.6. Сложение объекта и массива ............................................................................................. 289
15.7. Перегрузка [] и []= ............................................................................................................ 291
15.8. Перегрузка унарных операторов +, – и ! .......................................................................... 294
15.9. Какие операторы можно перегружать? ............................................................................ 295
15.10. DuckType-типизация ......................................................................................................... 297
Задания ......................................................................................................................................... 300
Глава 16. Ключевое слово self ................................................................................... 301
16.1. Ссылки на текущий объект ................................................................................................ 301
16.2. Значения self в разных контекстах .................................................................................... 304
16.3. Приемы использования self ................................................................................................ 305
16.3.1. Методы класса ........................................................................................................ 305
16.3.2. Цепочка обязанностей ............................................................................................ 308
16.3.3. Перегрузка операторов .......................................................................................... 309
16.3.4. Инициализация объекта блоком ............................................................................ 310
16.3.5. Открытие класса ..................................................................................................... 310
Задания ......................................................................................................................................... 311
Глава 17. Наследование ............................................................................................. 313
17.1. Наследование ...................................................................................................................... 313
17.2. Логические операторы ....................................................................................................... 316
17.3. Динамический базовый класс ............................................................................................ 317
17.4. Наследование констант ...................................................................................................... 318
17.5. Иерархия стандартных классов ......................................................................................... 319
17.6. Переопределение методов ................................................................................................. 320
17.7. Удаление методов ............................................................................................................... 322
17.8. Поиск метода....................................................................................................................... 326
Задания ......................................................................................................................................... 328
Глава 18. Области видимости ................................................................................... 331
18.1. Концепция видимости ........................................................................................................ 331
18.2. Открытые методы ............................................................................................................... 332
18.3. Закрытые методы ................................................................................................................ 333
18.4. Защищенные методы .......................................................................................................... 335
18.5. Закрытый конструктор ....................................................................................................... 337
18.6. Паттерн «Одиночка» (Singleton) ........................................................................................ 338
18.7. Вызов закрытых методов ................................................................................................... 341
18.8. Информационные методы .................................................................................................. 342
18.9. Области видимости при наследовании ............................................................................. 345
18.10. Области видимости методов класса ................................................................................ 346
Задания ......................................................................................................................................... 348
Оглавление 9
Глава 19. Модули......................................................................................................... 349
19.1. Создание модуля ................................................................................................................. 349
19.2. Оператор разрешения области видимости ....................................................................... 350
19.3. Пространство имен ............................................................................................................. 351
19.4. Вложенные классы и модули ............................................................................................. 352
19.5. Доступ к глобальным классам и модулям ........................................................................ 357
Задания ......................................................................................................................................... 361
Глава 20. Подмешивание модулей ........................................................................... 363
20.1. Класс Module ....................................................................................................................... 363
20.2. Подмешивание модулей в класс ........................................................................................ 365
20.3. Подмешивание модулей в объект...................................................................................... 369
20.4. Синглетон-методы модуля ................................................................................................. 373
20.5. Области видимости ............................................................................................................. 376
20.6. Стандартный модуль Kernel .............................................................................................. 379
20.7. Поиск методов в модулях .................................................................................................. 382
20.8. Метод prepend ..................................................................................................................... 386
20.9. Методы обратного вызова ................................................................................................. 387
20.10. Уточнения.......................................................................................................................... 393
20.11. Псевдонимы методов ....................................................................................................... 395
Задания ......................................................................................................................................... 397
Глава 21. Стандартные модули ................................................................................ 399
21.1. Модуль Math ....................................................................................................................... 399
21.2. Модуль Singleton ................................................................................................................. 402
21.3. Модуль Comparable ............................................................................................................ 404
21.4. Модуль Enumerable ............................................................................................................ 406
21.5. Модуль Forwardable ........................................................................................................... 408
21.6. Маршаллизация .................................................................................................................. 413
21.7. JSON-формат ....................................................................................................................... 416
21.8. YAML-формат .................................................................................................................... 418
Задания ......................................................................................................................................... 421
Глава 22. Свойства объектов .................................................................................... 423
22.1. Общие методы .................................................................................................................... 423
22.2. Неизменяемые объекты ...................................................................................................... 424
22.3. Заморозка объектов ............................................................................................................ 425
22.4. Небезопасные объекты ....................................................................................................... 426
Задания ......................................................................................................................................... 428
Глава 23. Массивы ...................................................................................................... 429
23.1. Модуль Enumerable ............................................................................................................ 429
23.2. Заполнение массива ............................................................................................................ 430
23.3. Извлечение элементов ........................................................................................................ 434
23.4. Поиск индексов элементов ................................................................................................ 439
23.5. Случайный элемент массива .............................................................................................. 439
23.6. Удаление элементов ........................................................................................................... 440
23.7. Замена элементов ................................................................................................................ 443
23.8. Информация о массиве ....................................................................................................... 445
23.9. Преобразование массива .................................................................................................... 446
10 Оглавление
23.10. Арифметические операции с массивами ........................................................................ 447
23.11. Логические методы ........................................................................................................... 448
23.12. Вложенные массивы ......................................................................................................... 451
23.13. Итераторы ......................................................................................................................... 453
23.14. Сортировка массивов ....................................................................................................... 455
Задания ......................................................................................................................................... 456
Глава 24. Хэши ............................................................................................................. 457
24.1. Создание хэша..................................................................................................................... 457
24.2. Заполнение хэша ................................................................................................................. 458
24.3. Извлечение элементов ........................................................................................................ 459
24.4. Поиск ключа ........................................................................................................................ 461
24.5. Обращение к несуществующему ключу ........................................................................... 461
24.6. Удаление элементов хэша .................................................................................................. 463
24.7. Информация о хэшах .......................................................................................................... 465
24.8. Хэши как аргументы методов ............................................................................................ 467
24.9. Объединение хэшей ............................................................................................................ 468
24.10. Преобразование хэшей ..................................................................................................... 468
24.11. Сравнение ключей ............................................................................................................ 471
24.12. Преобразование ключей хэша ......................................................................................... 474
Задания ......................................................................................................................................... 477
Глава 25. Классы коллекций .................................................................................... 479
25.1. Множество Set ..................................................................................................................... 479
25.2. Класс Struct .......................................................................................................................... 485
25.3. Класс OpenStruct ................................................................................................................. 489
Задания ......................................................................................................................................... 490
Глава 26. Исключения ................................................................................................ 493
26.1. Генерация и перехват исключений.................................................................................... 493
26.2. Исключения — это объекты .............................................................................................. 496
26.3. Стандартные ошибки .......................................................................................................... 497
26.4. Создание собственных исключений .................................................................................. 498
26.5. Перехват исключений......................................................................................................... 500
26.6. Многократная попытка выполнить код ............................................................................ 501
26.7. Перехват исключений: почти всегда плохо ...................................................................... 502
26.8. Блок ensure .......................................................................................................................... 502
26.9. Блок else ............................................................................................................................... 503
26.10. Перехват исключений в блоке ......................................................................................... 504
Задания ......................................................................................................................................... 504
Глава 27. Файлы .......................................................................................................... 505
27.1. Класс IO ............................................................................................................................... 505
27.2. Создание файла ................................................................................................................... 506
27.3. Режимы открытия файла .................................................................................................... 508
27.4. Закрытие файла ................................................................................................................... 510
27.5. Чтение содержимого файла ............................................................................................... 512
27.6. Построчное чтение файла .................................................................................................. 512
27.7. Запись в файл ...................................................................................................................... 515
Оглавление 11
27.8. Произвольный доступ к файлу .......................................................................................... 517
27.9. Пути к файлам ..................................................................................................................... 520
27.10. Манипуляция файлами ..................................................................................................... 522
Задания ......................................................................................................................................... 523
Глава 28. Права доступа и атрибуты файлов ........................................................ 525
28.1. Типы файлов ....................................................................................................................... 525
28.2. Определение типа файла .................................................................................................... 529
28.3. Время последнего доступа к файлу ................................................................................... 529
28.4. Права доступа в UNIX-подобной системе ........................................................................ 531
Задания ......................................................................................................................................... 534
Глава 29. Каталоги ...................................................................................................... 535
29.1. Текущий каталог ................................................................................................................. 535
29.2. Создание каталога............................................................................................................... 536
29.3. Чтение каталога .................................................................................................................. 537
29.4. Фильтрация содержимого каталога .................................................................................. 538
29.5. Рекурсивный обход каталога ............................................................................................. 539
29.6. Удаление каталога .............................................................................................................. 542
Задания ......................................................................................................................................... 542
Глава 30. Регулярные выражения ........................................................................... 543
30.1. Как изучать регулярные выражения? ................................................................................ 543
30.2. Синтаксический конструктор ............................................................................................ 544
30.3. Оператор =~ ........................................................................................................................ 545
30.4. Методы поиска .................................................................................................................... 546
30.4.1. Метод match ............................................................................................................ 546
30.4.2. Метод match? .......................................................................................................... 547
30.4.3. Метод scan .............................................................................................................. 548
30.5. Синтаксис регулярных выражений ................................................................................... 548
30.5.1. Метасимволы .......................................................................................................... 548
30.5.2. Экранирование ........................................................................................................ 553
30.5.3. Квантификаторы ..................................................................................................... 554
30.5.4. Опережающие и ретроспективные проверки ....................................................... 556
30.6. Модификаторы .................................................................................................................... 557
30.7. Где использовать регулярные выражения? ...................................................................... 560
30.8. Примеры .............................................................................................................................. 562
Задания ......................................................................................................................................... 565
Глава 31. Веб-программирование ............................................................................ 567
31.1. Протокол HTTP .................................................................................................................. 567
31.1.1. HTTP-заголовки ...................................................................................................... 570
31.1.2. HTTP-коды ответа .................................................................................................. 570
31.2. Веб-серверы ........................................................................................................................ 571
31.3. Гем Rack .............................................................................................................................. 572
31.3.1. Установка гема Rack .............................................................................................. 574
31.3.2. Простейшее Rack-приложение .............................................................................. 574
31.3.3. Управление утилитой rackup ................................................................................. 578
31.3.4. Обработка несуществующих страниц ................................................................... 579
12 Оглавление
31.3.5. Размер HTTP-содержимого ................................................................................... 580
31.3.6. Proc-объект в качестве Rack-приложения ............................................................ 582
31.3.7. Промежуточные слои (middleware) ....................................................................... 582
31.3.8. Роутинг .................................................................................................................... 583
31.3.9. Обработка статических файлов ............................................................................. 584
31.4. Ruby on Rails ....................................................................................................................... 587
31.4.1. Введение в Ruby on Rails ....................................................................................... 587
31.4.2. Установка Ruby on Rails......................................................................................... 588
31.4.3. Паттерн MVC .......................................................................................................... 591
31.4.4. Структура приложения Ruby on Rails ................................................................... 594
31.4.4.1. Каталог app ............................................................................................... 595
31.4.4.2. Окружения ................................................................................................ 595
31.4.4.3. Каталог config .......................................................................................... 596
31.4.4.4. Каталог db ................................................................................................ 596
31.4.4.5. Каталог lib ................................................................................................ 596
31.4.4.6. Каталог public .......................................................................................... 597
31.4.4.7. Каталог test ............................................................................................... 597
31.4.5. Rake-задачи ............................................................................................................. 597
31.4.6. Генераторы .............................................................................................................. 599
31.4.7. Стартовая страница ................................................................................................ 601
31.4.8. Представления ........................................................................................................ 604
Задания ......................................................................................................................................... 606
Глава 32. Автоматическое тестирование ............................................................... 607
32.1. Типы тестирования ............................................................................................................. 607
32.2. Преимущества и недостатки тестирования ...................................................................... 608
32.3. Фреймворки для тестирования .......................................................................................... 609
32.3.1. Фреймворк MiniTest ............................................................................................... 609
32.3.2. Фреймворк RSpec ................................................................................................... 613
32.3.3. Фреймворк Cucumber ............................................................................................. 620
Задания ......................................................................................................................................... 624
Заключение ................................................................................................................... 625
Приложение 1. Справочные таблицы ..................................................................... 627
П1.1. Ключевые слова ................................................................................................................. 627
П1.2. Синтаксические конструкторы ......................................................................................... 628
П1.3. Экранирование ................................................................................................................... 629
П1.4. Переменные и константы .................................................................................................. 629
П1.5. Операторы .......................................................................................................................... 632
П1.6. Конструкции ветвления и циклы ...................................................................................... 635
П1.7. Итераторы ........................................................................................................................... 635
Приложение 2. Содержимое электронного архива ............................................... 637
Предметный указатель .............................................................................................. 639

 

 

Torrent file:

magnet:?xt=urn:btih:CADB6B856AF4485178393C43DA1D63DB65F0D3B7