Merge remote-tracking branch 'upstream/master'

src/js/dialogs/nextLevel.js

@@ -103,9 +103,9 @@ exports.dialog = {
     type: 'ModalAlert',
     options: {
       markdowns: [
-        '## Чудово !!',
+        '## Молодець!',
         '',
-        'Ти пройшов рівень використавши *{numCommands}* команди; ',
+        'Ти пройшов рівень. Кількість використаних команд \u2014 *{numCommands}*; ',
         'наш розв’язок складається з {best}.'
       ]
     }

src/js/dialogs/sandbox.js

@@ -251,7 +251,7 @@ exports.dialog = {
       markdowns: [
         '## 欢迎光临 Learn Git Branching!',
         '',
-        '本应用旨在帮助初学者领会 git 分支背后的强大概念。',
+        '本应用旨在帮助初学者领会 Git 分支背后的强大概念。',
         '希望你能喜欢这个应用，并学到知识！',
         '',
         '# 演示!',
@@ -515,19 +515,19 @@ exports.dialog = {
       markdowns: [
         '## Ласкаво просимо до Learn Git Branching',
         '',
-        'Хочеш вивчити Git? Тоді ти знайшов, що шукав!',
+        'Хочеш вивчити Git? Тоді ти знайшов те, що шукав!',
-        '"Learn Git Branching" це найвізуальніший та найінтерактивніший спосіб вивчення Git ',
+        '"Learn Git Branching" \u2014 це найбільш візуальний та інтерактивний спосіб вивчення Git в Інтернеті. ',
-        'який можна знайти в інтернеті; ти зможеш проходити захоплюючі рівні, дивитися',
+        'Ти зможеш проходити захоплюючі рівні, дивитися ',
-        'покрокові інструкції використання потужних функцій git, й можливо навіть трохи ',
+        'покрокові інструкції з використання потужних функцій Git, навіть трохи ',
         'розважитись в процесі навчання.',
         '',
-        'Після цього діалогу ти побачиш список доступних рівнів. Якщо ти новачок ',
+        'Після цього діалогу побачиш список доступних рівнів. Якщо ти новачок, ',
-        'просто почни з першого рівня. Якщо ти вже знаєш основи Git, ',
+        'просто почни з першого рівня. Якщо вже знаєш основи Git, ',
         'спробуй більш складні рівні в кінці.',
         '',
-        'PS: Хочеш перейти одразу до пісочниці наступного разу?',
+        'P.S. Хочеш перейти одразу до пісочниці наступного разу?',
         'Спробуй ',
-        '[це спеціяльне посилання](http://pcottle.github.io/learnGitBranching/?NODEMO)'
+        '[це спеціальне посилання.](http://pcottle.github.io/learnGitBranching/?NODEMO)'
       ]
     }
   }]

src/js/intl/strings.js

@@ -39,7 +39,7 @@ exports.strings = {
     'es_AR': '¡Fabuloso! Igualaste o superaste nuestra solución.',
     'fr_FR': 'Fabuleux ! Votre solution a égalé ou surpassé notre solution.',
     'ru_RU': 'Отлично! Ваше решение соответствует или превосходит наше.',
-    'uk': 'Чудово! Твій розв’язок на рівні чи можливо навіть краще від нашого'
+    'uk': 'Чудово! Твій розв’язок на рівні або краще від нашого.'
   },
   ///////////////////////////////////////////////////////////////////////////
   'finish-dialog-lose': {
@@ -73,7 +73,7 @@ exports.strings = {
     '__desc__': 'warning for when using -A option',
     'en_US': 'The -A option is not needed for this app, just commit away!',
     'zh_TW': '對於這個 app 來說，-A 選項並不是必須的，只需要 commit 就好！',
-    'zh_CN': '对本 app 而言，-A 选项并非必须项，直接 commit 就好！',
+    'zh_CN': '对本 App 而言，-A 选项并非必须项，直接 commit 就好！',
     'es_AR': 'La opción -A no es necesaria para esta aplicación, simplemente hacé commit',
     'pt_BR': 'A opção -A não é necessária para este aplicativo, simplesmente faça commit',
     'de_DE': 'Die Option -A wird in dieser Anwendung nicht benötigt, committe einfach!',
@@ -347,7 +347,7 @@ exports.strings = {
     '__desc__': 'One of the warning messages for git',
     'en_US': 'Warning!! Detached HEAD state',
     'de_DE': 'Achtung! Detached HEAD Zustand',
-    'zh_CN': '警告！现在是脑袋搬家（Detached HEAD）状态',
+    'zh_CN': '警告！现在是分离 HEAD（Detached HEAD）状态',
     'zh_TW': '注意喔！現在的狀態是分離 Head',
     'es_AR': '¡Cuidado! Modo de detached HEAD',
     'pt_BR': 'Cuidado! Modo Detached HEAD',
@@ -430,7 +430,7 @@ exports.strings = {
     'en_US': 'There is no concept of adding / staging files, so that option or ' +
       'command is invalid!',
     'de_DE': 'In dieser Demo gibt es kein Hinzufügen / Vormerken von Dateien, dieser Befehl ist daher ungültig!',
-    'zh_CN': '没有添加、缓存文件的必要，所以改选项或者命令是不合法的。',
+    'zh_CN': '没有添加、缓存文件的必要，所以该选项或者命令是不合法的。',
     'zh_TW': '沒有加入、或者暫存 (staging) 文件的必要，所以改選項或者命令是不合法的。',
     'es_AR': 'No existe el concepto de agregar/indexar cambios, así que esa opción o comando es inválido',
     'pt_BR': 'Não existe o conceito de adicionar/indexar mudanças, de forma que essa opção ou comando é inválida',
@@ -575,7 +575,7 @@ exports.strings = {
   'bad-tag-name': {
     '__desc__': 'When the user enters a tag name thats not ok',
     'en_US': 'That tag name "{tag}" is not allowed!',
-    'zh_CN': '该标签名 “{tag}” 不被接受。233',
+    'zh_CN': '该标签名 “{tag}” 不被接受。',
     'es_AR': 'El nombre "{tag}" no está permitido para los tags',
     'pt_BR': 'Uma tag não pode ser chamada de "{tag}"!',
     'de_DE': 'Der Tag-Name "{tag}" ist nicht erlaubt!',
@@ -703,7 +703,7 @@ exports.strings = {
     '__desc__': 'command output title from "show"',
     'en_US': 'Please use one of the following commands for more info:',
     'zh_TW': '請使用下列其中一個指令取得更多資訊：',
-    'zh_CN': '请使用以下命令以了解更多',
+    'zh_CN': '请使用以下命令以了解更多：',
     'de_DE': 'Bitte benutze einen der folgenden Befehle um mehr Informationen zu bekommen:',
     'es_AR': 'Usá alguno de estos comandos para tener más información:',
     'pt_BR': 'Use algum destes comandos para ter mais informações:',
@@ -1147,7 +1147,7 @@ exports.strings = {
     '__desc__': 'The general error when we encounter a dialog that is not translated',
     'en_US': 'This dialog or text is not yet translated in your locale :( Hop on github to aid in translation!',
     'de_DE': 'Dieser Dialog oder Text ist noch nicht in deine Sprache übersetzt. :( Schau auf Github vorbei um bei der Übersetzung zu helfen!',
-    'zh_CN': '这段对话还没有被翻译成您的语言 :( 欢迎在 Github 上贡献你的翻译!',
+    'zh_CN': '这段对话还没有被翻译成您的语言 :( 欢迎在 Github 上贡献您的翻译!',
     'zh_TW': '這段對話尚未翻成您的語言 :( 歡迎到 Github 貢獻翻譯！',
     'es_AR': 'Este mensaje o texto aún no fue traducido a tu idioma :( ¡Metete en Github y ayudanos a traducirlo!',
     'pt_BR': 'Esta mensagem ou texto não foi traduzida para Português :( Ajude-nos a traduzir no Github!',

src/js/views/index.js

@@ -309,7 +309,7 @@ var ModalTerminal = ContainedBase.extend({
 
     this.container = new ModalView();
     this.JSON = {
-      title: options.title || 'Heed This Warning!'
+      title: options.title 
     };
 
     this.render();
@@ -344,9 +344,7 @@ var ModalAlert = ContainedBase.extend({
       this.JSON.markdown = options.markdowns.join('\n');
     }
 
-    this.container = new ModalTerminal({
+    this.container = new ModalTerminal({});
-      title: 'Alert!'
-    });
     this.render();
 
     if (!options.wait) {

src/levels/advanced/multipleParents.js

@@ -341,7 +341,7 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "使用`^`和`~`可以自由在在提交树中移动："
+              "使用 `^` 和 `~` 可以自由地在提交树中移动："
             ],
             "afterMarkdowns": [
               "快若闪电！"
@@ -371,7 +371,7 @@ exports.level = {
               "",
               "要完成此关，在指定的目标位置创建一个新的分支。",
               "",
-              "很明显可以简单的直接使用提交记录的hash值（比如`C6`），但我要求你使用刚刚讲到的相对引用修饰符！"
+              "很明显可以简单地直接使用提交记录的 hash 值（比如 `C6`），但我要求你使用刚刚讲到的相对引用修饰符！"
             ]
           }
         }

src/levels/index.js

@@ -73,7 +73,7 @@ var sequenceInfo = exports.sequenceInfo = {
       'fr_FR': 'Une introduction en douceur à la majorité des commandes git',
       'es_AR': 'Una breve introducción a la mayoría de los comandos de git',
       'pt_BR': 'Uma breve introdução à maioria dos comandos do git',
-      'zh_CN': '循序渐进介绍git主要命令',
+      'zh_CN': '循序渐进介绍 Git 主要命令',
       'zh_TW': '循序漸進地介紹 git 主要命令',
       'ko'   : 'git의 주요 명령어를 깔끔하게 알려드립니다',
       'ru_RU': 'Хорошо подобранное введение в основные команды git',
@@ -101,7 +101,7 @@ var sequenceInfo = exports.sequenceInfo = {
       'fr_FR': 'Le prochain excellent plat de pur git. J\'espère que vous êtes affamés',
       'es_AR': 'La próxima porción de 100% maravillas git. Espero que estés hambriento',
       'pt_BR': 'A próxima porção de maravilhas do git. Faminto?',
-      'zh_CN': '接下来是git的超赞特性。迫不及待了吧！',
+      'zh_CN': '接下来是 Git 的超赞特性。迫不及待了吧！',
       'zh_TW': '接下來是 git 非常厲害的地方！相信你已經迫不及待了吧！',
       'ru_RU': 'Следующая порция абсолютной git-крутотенюшки. Проголодались?',
       'uk'   : 'Наступна порція абсолютної git-дивожнечі. Зголодніли?',

src/levels/intro/branching.js

@@ -12,7 +12,7 @@ exports.level = {
     "zh_CN": "建立 Git 分支",
     "zh_TW": "建立 git branch",
     "ru_RU": "Ветвление в Git",
-    "uk": "Розгалудження в Git"
+    "uk": "Розгалуження в Git"
   },
   "hint": {
     "en_US": "Make a new branch with \"git branch [name]\" and check it out with \"git checkout [name]\"",
@@ -103,7 +103,11 @@ exports.level = {
           "options": {
             "markdowns": [
               "Ok! You are all ready to get branching. Once this window closes,",
-              "make a new branch named `bugFix` and switch to that branch"
+              "make a new branch named `bugFix` and switch to that branch.",
+              "",
+              "By the way here here's a shortcut: if you want to create a new ",
+              "branch AND check it out at the same time, you can simply ",
+              "type `git checkout -b [yourbranchname]`."
             ]
           }
         }
@@ -546,7 +550,7 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "使用如下命令告诉git我们想要切换到新的分支",
+              "使用如下命令告诉 Git 我们想要切换到新的分支",
               "",
               "```",
               "git checkout [name]",
@@ -814,15 +818,15 @@ exports.level = {
             "markdowns": [
               "## Гілки в Git",
               "",
-              "Гілки в Git також є дивовижно легкі. Це просто посилання на конкретний коміт  -- нічого більше. Через це багато Git ентузіастів повторюють мантру:",
+              "Гілки в Git також є дивовижно легкими. Вони є просто посиланнями на конкретний коміт, нічого більше. Через це багато Git-ентузіастів повторюють мантру:",
               "",
               "```",
               "роби гілки завчасно, роби гілки часто",
               "```",
               "",
-              "Через те що сворення нових гілок ніяк не впливає на використання памяті чи дискового простору, набагато простіше розділити свою роботу на кілька гілок, що містять логічно звязаний функціонал, ніж працювати з величезними гілками.",
+              "Через те, що сворення нових гілок ніяк не впливає на використання пам’яті чи дискового простору, набагато простіше розділити свою роботу на кілька логічно зв’язаних по функціоналу гілок, ніж працювати з величезними гілками.",
               "",
-              "Коли ми почнемо використовувати гілки та коміти ми побачимо як вони поєднуються між собою. Але зараз просто запам’ятай що гілка, в принципі, просто зберігає роботу теперішнього коміту і всіх його попередників."
+              "Коли ми почнемо використовувати гілки та коміти, ми побачимо, як вони поєднуються між собою. Але зараз просто запам’ятай, що гілка просто зберігає роботу теперішнього коміту і всіх його попередників."
             ]
           }
         },
@@ -830,12 +834,12 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "Давайте на практиці подивимось як вигдядають гілки в Git ",
+              "Давайте на практиці подивимось, як виглядають гілки в Git.",
               "",
-              "Зараз ми створимо нову гілку, яка звется `newImage`"
+              "Зараз ми створимо нову гілку `newImage`."
             ],
             "afterMarkdowns": [
-              "Ось і все що треба знати про гілкування! Гілка `newImage` тепер посилається на коміт `C1`"
+              "Ось і все, що треба знати про гілки. Гілка `newImage` тепер посилається на коміт `C1`."
             ],
             "command": "git branch newImage",
             "beforeCommand": ""
@@ -845,10 +849,10 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "Давайте спробуємо додати якусь інформацію до цієї нової гілки. Натисни кнопку внизу"
+              "Давайте спробуємо додати якусь інформацію до цієї нової гілки. Натисни кнопку внизу."
             ],
             "afterMarkdowns": [
-              "От халепа! Гілка `master` просунулася вперед але гілка `newImage` ні! Це тому що ми були не \"на\" новій гілці, й тому зірочка (*) була поруч з  `master`"
+              "От халепа! Гілка `master` просунулася вперед, але гілка `newImage` \u2014 ні! Це тому, що ми були не \"на новій гілці\". Через це зірочка (*) була поруч з  `master`."
             ],
             "command": "git commit",
             "beforeCommand": "git branch newImage"
@@ -858,16 +862,16 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "Давайте вкажемо git що ми хочемо перейти на нову гілку за допомогою",
+              "Давайте вкажемо Git, що ми хочемо перейти на нову гілку за допомогою",
               "",
               "```",
               "git checkout [ім’я]",
               "```",
               "",
-              "Ця команда перекине нас на нову гілку до того як ми закомітимо наші зміни."
+              "Ця команда перекине нас на нову гілку до того, як ми закомітимо наші зміни."
             ],
             "afterMarkdowns": [
-              "Ось і все! Наші зміни були записані в нову гілку"
+              "Ось і все! Наші зміни були записані в нову гілку."
             ],
             "command": "git checkout newImage; git commit",
             "beforeCommand": "git branch newImage"
@@ -877,8 +881,8 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "Ок! Тепер ти готовий до гілкування. Як тільки це вікно зчезне,",
+              "Тепер ти готовий до створення гілок. Як тільки це вікно пропаде, ",
-              "зроби нову гілку з назвою `bugFix` й перейди на нову гілку"
+              "зроби нову гілку з назвою `bugFix` та перейди на неї."
             ]
           }
         }

src/levels/intro/commits.js

@@ -10,7 +10,7 @@ exports.level = {
     'zh_CN': 'Git Commits 简介',
     'zh_TW': '介紹 git commit ',
     'ru_RU': 'Знакомство с Git Commit ',
-    'uk': 'Знайомство з Git Commit'
+    'uk': 'Знайомство з комітами в Git'
   },
   "goalTreeString": "{\"branches\":{\"master\":{\"target\":\"C3\",\"id\":\"master\"}},\"commits\":{\"C0\":{\"parents\":[],\"id\":\"C0\",\"rootCommit\":true},\"C1\":{\"parents\":[\"C0\"],\"id\":\"C1\"},\"C2\":{\"parents\":[\"C1\"],\"id\":\"C2\"},\"C3\":{\"parents\":[\"C2\"],\"id\":\"C3\"}},\"HEAD\":{\"target\":\"master\",\"id\":\"HEAD\"}}",
   "solutionCommand": "git commit;git commit",
@@ -343,7 +343,7 @@ exports.level = {
           "options": {
             "markdowns": [
               "## Git Commits",
-              "git仓库中的一次提交（commit）记录目录下所有文件的快照。感觉像是大量的复制和粘贴，但 git 做的不只这么简单！",
+              "Git 仓库中的一次提交（commit）记录目录下所有文件的快照。感觉像是大量的复制和粘贴，但 Git 做的不只这么简单！",
               "",
               "Git 希望提交记录尽可能地轻量，所以每次进行提交时，它不会简单地复制整个目录。实际上它把每次提交记录保存为从代码库的一个版本到下一个版本的变化集，或者说一个\"增量（delta）\"。所以，大部分提交记录都有一个父提交（parent commit）-- 我们会很快演示这一点。",
               "",
@@ -359,7 +359,7 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "在实践中学习commit。右边是一个（小）git代码库的图示。当前有两个提交记录—— 初始提交`C0`和其后可能包含有用修改的提交`C1`。",
+              "在实践中学习 commit。右边是一个（小）Git 代码库的图示。当前有两个提交记录—— 初始提交 `C0` 和其后可能包含有用修改的提交 `C1`。",
               "",
               "点击下面的按钮生成新的提交记录。"
             ],
@@ -471,13 +471,13 @@ exports.level = {
           "options": {
             "markdowns": [
               "## Коміти в Git",
-              "Коміт в git репозиторії зберігає моментальну копію всіх файлів в поточній директорії. Це як гігантська копіпаста, навіть краще!",
+              "Коміт в Git репозиторії зберігає моментальну копію всіх файлів в поточній директорії. Це як гігантська копіпаста, тільки краще.",
               "",
-              "Git намагається зберігати коміти як можна простіше й ефективніше, тому він не просто втупу копіює всю директорію при кожному коміті. Він може (наскільки це можливо) стиснути коміт як набір правок, чи \"дельту\", між двома версіями репозиторію .",
+              "Git намагається зберігати коміти якнайпростіше й ефективніше, тому він не просто копіює всю директорію при кожному коміті. Він може стиснути коміт в набір правок чи \"дельту\" між двома версіями репозиторію.",
               "",
-              "Git також зберігає історію коли і ким був створений тий чи інший коміт. Тому більшість комітів мають комітів-предків, що знаходяться вище в ієрархії -- ми це зоображуємо стрілочками в нашій візуалізації. Історія це необхідна річ для кожного хто працює з конкретним проектом!",
+              "Git також зберігає історію коли і ким був створений той чи інший коміт. Тому більшість комітів мають комітів-предків, що знаходяться вище в ієрархії \u2014 ми це зоображуємо стрілочками в нашій візуалізації. Історія \u2014 це необхідна річ для кожного, хто працює з конкретним проектом.",
               "",
-              "Тут є багато над чим подумати, але наразі ти можеш уявляти коміти як моментальні знімки проекту. Коміти майже невагомі й перемикання між ними убер швидке!"
+              "Тут є багато над чим подумати, але наразі ти можеш уявляти коміти як моментальні знімки проекту. Коміти майже невагомі й перемикання між ними дуже швидке."
             ]
           }
         },
@@ -485,12 +485,12 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "Давай, подивимось як це виглядає на практиці. Справа зоображена візуалізація (маленького) git репозиторію. Наразі ми бачимо два коміти -- перший початковий коміт, `C0`, й один наступний коміт `C1` який містить якісь змістовні зміни.",
+              "Давай подивимось, як це виглядає на практиці. Справа зоображена візуалізація маленького Git-репозиторію. Наразі ми бачимо два коміти: початковий коміт `C0`, та наступний коміт `C1`, який містить якісь змістовні зміни.",
               "",
-              "Натисни кнопку нижче щоб створити новий коміт"
+              "Натисни кнопку нижче, щоб створити новий коміт."
             ],
             "afterMarkdowns": [
-              "Чудово. Ми тіки що зробили деякі зміни з репозиторієм й зберегли їх як новий коміт. Цей коміт має предка `C1`, який вказує на коміт з якого він був створений."
+              "Чудово. Ми щойно зробили деякі зміни з репозиторієм і зберегли їх як новий коміт. Цей коміт має предка `C1`, який вказує на коміт, з якого він був створений."
             ],
             "command": "git commit",
             "beforeCommand": ""
@@ -500,7 +500,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "Спробуй! Після того як це вікно закриється зроби два коміти щоб пройти цей рівень."
+              "Спробуй сам. Після того як це вікно закриється, зроби два коміти, щоб пройти цей рівень."
             ]
           }
         }

src/levels/intro/merging.js

@@ -488,7 +488,7 @@ exports.level = {
             ],
             "command": "git checkout bugFix; git merge master",
             "afterMarkdowns": [
-              "因为 `bugFix` 分支在 `master` 分支的下游，git什么都不用做，只是简单地把`bugfix`分支移动到`master`指向的提交记录。",
+              "因为 `bugFix` 分支在 `master` 分支的下游，Git 什么都不用做，只是简单地把 `bugfix` 分支移动到 `master` 指向的提交记录。",
               "",
               "现在所有的提交记录的颜色都是一样的啦，这表明每一个分支都包含了代码库的所有修改！走起！"
             ],

src/levels/intro/rebasing.js

@@ -439,7 +439,7 @@ exports.level = {
             "markdowns": [
               "## Git Rebase",
               "",
-              "*rebasing*是在分支之间合并工作的第二种方法。Rebasing就是取出一系列的提交记录，\"复制\"它们，然后把在别的某个地方放下来。",
+              "*Rebasing* 是在分支之间合并工作的第二种方法。Rebasing 就是取出一系列的提交记录，\"复制\"它们，然后把在别的某个地方放下来。",
               "",
               "虽然听上去难以理解，rebasing 的优势是可以创造更线性的提交历史。假如只允许使用 rebasing，代码库的提交日志/历史会更好看。",
               "",

src/levels/mixed/describe.js

@@ -226,7 +226,7 @@
             "markdowns": [
               "### git describe",
               "",
-              "因为 tag 在 commit tree 上表示的是一个锚点，git 有一个指令可以用来*显示*离你最近的锚点（也就是 tag），而且这个指令叫做 `git describe`！",
+              "因为 tag 在 commit tree 上表示的是一个锚点，Git 有一个指令可以用来*显示*离你最近的锚点（也就是 tag），而且这个指令叫做 `git describe`！",
               "",
               "当你已经完成了一个 `git bisect`（一个找寻有 bug 的 commit 的指令），或者是当你使用的是你跑去度假的同事的电脑时， `git describe` 可以帮助你了解你离最近的 tag 差了多少个 commit。"
             ]
@@ -240,7 +240,7 @@
               "",
               "`git describe <ref>`",
               "",
-              "`<ref>` 是任何一个可以被 git 解读成 commit 的位置，如果你没有指定的话，git 会以你目前所在的位置为准（`HEAD`）。",
+              "`<ref>` 是任何一个可以被 Git 解读成 commit 的位置，如果你没有指定的话，Git 会以你目前所在的位置为准（`HEAD`）。",
               "",
               "指令的输出就像这样：",
               "",

src/levels/mixed/tags.js

@@ -23,7 +23,7 @@
     "es_AR": "Podés checkoutear directamente el commit, ¡o simplemente el tag!",
     "pt_BR": "Você pode fazer checkout diretamente no commit ou na tag correspondente!",
     "zh_TW": "你可以直接 checkout 到 commit 上，或是簡單的 checkout 到 tag 上",
-    "zh_CN": "你可以直接 checkout 到 commit 上，或是简单的 checkout 到 tag 上",
+    "zh_CN": "你可以直接 checkout 到 commit 上，或是简单地 checkout 到 tag 上",
     "ru_RU": "Можно сделать checkout напрямую на коммит или же на тег",
     "ko"   : "커밋을 직접 또는 태그를 이용해서 체크아웃할수 있습니다!",
     "uk"   : "ти можеш або зробити checkout коміта напряму чи просто зачекаутити таг!"
@@ -219,7 +219,7 @@
               "让我们试着建立一个 tag，指向 commit `C1`，表示这是我们第一个版本。"
             ],
             "afterMarkdowns": [
-              "看吧！非常容易，我们命名这个 tag 叫做`v1`，并且让它指向 commit `C1`，如果你离开了该 commit，git 会根据 `HEAD` 所指向的位置才分辨。"
+              "看吧！非常容易，我们命名这个 tag 叫做 `v1`，并且让它指向 commit `C1`，如果你离开了该 commit，Git 会根据 `HEAD` 所指向的位置才分辨。"
             ],
             "command": "git tag v1 C1",
             "beforeCommand": "git commit"

src/levels/rampup/cherryPick.js

@@ -326,9 +326,9 @@
             "markdowns": [
               "## 转移工作区",
               "",
-              "到现在我们已经学习了git的基础命令 -- commit, branch, checkout. 这些概念实现了git 90% 的功能, 同样也满足了开发者的主要需求 ",
+              "到现在我们已经学习了 Git 的基础命令 -- commit, branch, checkout. 这些概念实现了 Git 90% 的功能, 同样也满足了开发者的主要需求 ",
               "",
-              "然而, 剩余的10% 可能在处理复杂的工作流时(或者当你陷入困惑时), 非常的重要. 我们会在下一个概念中涉及'转移工作区', 换句话说, 这是开发者表达'我想要把这个工作放这里, 那个工作也放这里', 精确的说, 这是很灵活的方式    ",
+              "然而, 剩余的 10% 可能在处理复杂的工作流时(或者当你陷入困惑时), 非常的重要. 我们会在下一个概念中涉及'转移工作区', 换句话说, 这是开发者表达'我想要把这个工作放这里, 那个工作也放这里', 精确地说, 这是很灵活的方式    ",
               "",
               "看起来内容很多, 其实概念相当简单"
             ]
@@ -356,7 +356,7 @@
               "现在有一个仓库, 我们想将 `side` 分支下的工作复制到 `master` 分支, 我们可以通过 `rebase` 完成这一点(已经学过了哈), 但是这里我们想通过 `cherry-pick` 来完成."
             ],
             "afterMarkdowns": [
-              "这是它啦, 我们需要的是提交对象`C2` 和 `C4` ,所以 git 将被它们抓取到当前分支下了. 就是这么简单!"
+              "这是它啦, 我们需要的是提交对象`C2` 和 `C4` ,所以 Git 将被它们抓取到当前分支下了. 就是这么简单!"
             ],
             "command": "git cherry-pick C2 C4",
             "beforeCommand": "git checkout -b side; git commit; git commit; git commit; git checkout master; git commit;"

src/levels/rampup/detachedHead.js

@@ -429,7 +429,7 @@ exports.level = {
               "",
               "在接触 Git 的更多高级主题之前，我们先学习用不同的方法在代表你的项目的提交记录树上前后移动。",
               "",
-              "一旦能够熟练地在Git中前进后退，你使用其他git命令的威力也会被放大！",
+              "一旦能够熟练地在 Git 中前进后退，你使用其他 Git 命令的威力也会被放大！",
               ""
             ]
           }
@@ -442,7 +442,7 @@ exports.level = {
               "",
               "我们首先看一下\"HEAD\". HEAD 是当前提交记录的符号名称 -- 其实就是你正在其基础进行工作的提交记录。",
               "",
-              "HEAD总是指向最近一次提交记录，表现为当前工作树。大多数修改工作树的git命令都开始于改变HEAD指向。",
+              "HEAD 总是指向最近一次提交记录，表现为当前工作树。大多数修改工作树的 Git 命令都开始于改变 HEAD 指向。",
               "",
               "HEAD 通常指向分支名（比如 bugFix）。你提交时，改变了 bugFix 的状态，这一变化通过 HEAD 变得可见。"
             ]

src/levels/rampup/interactiveRebase.js

@@ -238,7 +238,7 @@
               "",
               "如果你知道你所需要的提交对象(相应的 hash), 那用 Git cherry-pick 就非常方便了 -- 很难有简单的方式了",
               "",
-              "但是如果你不清楚你想要的提交对象的hash呢? 幸好git 帮你想到了这一点, 我们可以利用交互rebase -- 如果你想衍合一系列的提交, 这就是最方便的方法了",
+              "但是如果你不清楚你想要的提交对象的 hash 呢? 幸好 Git 帮你想到了这一点, 我们可以利用交互 rebase -- 如果你想衍合一系列的提交, 这就是最方便的方法了",
               "",
               "让我们看看细节.."
             ]
@@ -250,9 +250,9 @@
             "markdowns": [
               "交互式 rebase 指的是 rebase 后跟一个参数: `-i`",
               "",
-              "如果你包含了这个选项, git 会开启一个UI 并 展示出将要被复制到目标的提交对象, 它也会显示它们的提交hash 和 信息",
+              "如果你包含了这个选项, Git 会开启一个 UI 并 展示出将要被复制到目标的提交对象, 它也会显示它们的提交 hash 和信息",
               "",
-              "真实的git , UI 窗口指的是在类似于vim的文本编辑器中打开一个文件. 考虑到我们的目标, 我建立了一个小型的会话窗口以完成相同的事儿."
+              "真实的 Git, UI 窗口指的是在类似于 Vim 的文本编辑器中打开一个文件. 考虑到我们的目标, 我建立了一个小型的会话窗口以完成相同的事儿."
             ]
           }
         },
@@ -277,7 +277,7 @@
               "当你点这个按钮时, 一个交互式的 rebase 窗口就会出现. 对提交对象做个排序, 再看看结果"
             ],
             "afterMarkdowns": [
-              "按照你指定的方式, git 克隆了这些提交"
+              "按照你指定的方式, Git 克隆了这些提交"
             ],
             "command": "git rebase -i HEAD~4 --aboveAll",
             "beforeCommand": "git commit; git commit; git commit; git commit"

src/levels/rampup/relativeRefs2.js

@@ -435,7 +435,7 @@ exports.level = {
             "markdowns": [
               "### \"~\" 符號",
               "",
-              "假設需要在 commit tree 中向上移動多個 commit。使用太多 `^` 會非常討人厭，所以 git 也加入了波浪（~）符號。",
+              "假設需要在 commit tree 中向上移動多個 commit。使用太多 `^` 會非常討人厭，所以 Git 也加入了波浪（~）符號。",
               "",
               "",
               "波浪符號後面可以選擇一個數字（你也可以不選擇），該數字可以告訴 Git 我要向上移動多少個 commit 。舉個例子"

src/levels/rebase/manyRebases.js

@@ -148,7 +148,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "### 多分支衍合",
+              "### 多分支 rebase",
               "",
               "呐，现在我们有很多分支啦！让我们 rebase 这些分支的工作到 master 分支上吧。",
               "",

src/levels/remote/clone.js

@@ -339,7 +339,7 @@ exports.level = {
             "markdowns": [
               "## 我们创建远端仓库的命令",
               "",
-              "直到现在, 教学都聚焦于本地仓库的基本操作. 但我们现在需要学习远端仓库的操作 -- 我们需要一个配置这种环境的命令, 这个命令就是 `git clone`",
+              "直到现在, 教学都聚焦于本地仓库的基本操作. 但我们现在需要学习远端仓库的操作 -- 我们需要一个配置这种环境的命令, 这个命令就是 `git clone`. ",
               "技术上, `git clone` 在真实的环境下, 会在本地创建一个远端仓库的拷贝(比如从 github.com). 在我们的教学中使用这个命令会有一些不同 -- 它会在远端创建一个你本地的拷贝. 这和真实命令的意思相反",
               ""
             ]
@@ -363,7 +363,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "要完成本节, 简单的 `git clone` 下你的仓库. 后续的课程我们会正式的学习"
+              "要完成本节, 简单地 `git clone` 下你的仓库. 后续的课程我们会正式地学习"
             ]
           }
         }

src/levels/remote/fetch.js

@@ -402,7 +402,7 @@ exports.level = {
             "markdowns": [
               "## Git Fetch",
               "",
-              "git remote可以归结为向其它仓库推送/拉取数据. 只要我们能回溯或前推提交, 我们就可以分享任何类型的被git跟踪的更新(工作, 新想法, 情书等等)",
+              "git remote 可以归结为向其它仓库推送/拉取数据. 只要我们能回溯或前推提交, 我们就可以分享任何类型的被 Git 跟踪的更新(工作, 新想法, 情书等等)",
               "",
               "本节课我们将学习 如何从远端仓库获取数据 -- 这个命令叫 `git fetch`",
               "",

src/levels/remote/fetchArgs.js

@@ -689,9 +689,9 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "你可能会好奇 -- 为何git 会将新提交压入到o/foo 而不是 压入到我本地的foo. 我想 <place>参数就是同时存在于本地和远端 的 <place> ",
+              "你可能会好奇 -- 为何 Git 会将新提交压入到 o/foo 而不是压入到我本地的 foo. 我想 <place> 参数就是同时存在于本地和远端的 <place> ",
               "",
-              "好吧, 本例中git 有个特殊例外, 因为你可能位于foo 分支, 你也不想弄乱它. 这得联系之前的课程 -- 它不会更新你的本地工作, 它只是下载提交(这样, 稍后你可以检查 或者 合并之).  ",
+              "好吧, 本例中 Git 有个特殊例外, 因为你可能位于 foo 分支, 你也不想弄乱它. 这得联系之前的课程 -- 它不会更新你的本地工作, 它只是下载提交(这样, 稍后你可以检查或者合并之).  ",
               ""
             ]
           }
@@ -717,7 +717,7 @@ exports.level = {
               "我们看看更疯狂的例子:"
             ],
             "afterMarkdowns": [
-              "哇! 看见了吧, git 将`foo~1` 解析成一个origin的位置, 然后下载到了本地`bar`. 注意foo 和 o/foo都没有得到更新 (因为我们指定了destination)."
+              "哇! 看见了吧, Git 将 `foo~1` 解析成一个 origin 的位置, 然后下载到了本地 `bar`. 注意 foo 和 o/foo 都没有得到更新 (因为我们指定了 destination)."
             ],
             "command": "git fetch origin foo~1:bar",
             "beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
@@ -730,7 +730,7 @@ exports.level = {
               "如果 destination 不存在呢? 我们看看上个幻灯片(不含 bar)! "
             ],
             "afterMarkdowns": [
-              "看见了吧, 它就像是git push. Git会在fetch前自己确立本地destination, 就像是git在push时, 会自己在remote确立destination(如果它不存在的话)一样"
+              "看见了吧, 它就像是 git push. Git 会在 fetch 前自己确立本地 destination, 就像是 Git 在 push 时, 会自己在 remote 确立 destination (如果它不存在的话)一样"
             ],
             "command": "git fetch origin foo~1",
             "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"

src/levels/remote/fetchRebase.js

@@ -765,9 +765,9 @@ exports.level = {
             "markdowns": [
               "想象一下你周一克隆了一个仓库, 然后在一个特性分支上工作. 到周五时, 你准备推送你的特性分支 -- 不行的! 你的同事这周写了一堆代码, 使得你的特性分支过期了. 他们已经将代码分享(合并)到远端仓库了, 所以你的工作就变成了基于仓库老版的代码了.",
               "",
-              "这种情况下, `git push`就变得模糊了, 如果你执行`git push`, git应该让远端仓库回到星期一那天? 还是直接在新代码的基础上添加你的代码? 或者直接忽略你的提交? ",
+              "这种情况下, `git push` 就变得模糊了, 如果你执行 `git push`, Git 应该让远端仓库回到星期一那天? 还是直接在新代码的基础上添加你的代码? 或者直接忽略你的提交? ",
               "",
-              "因为这情况让问题变得模糊(因为历史的分散性)了, git 不会允许你`push`. 你只能先合并远端最新的代码, 然后才能分享你的工作."
+              "因为这情况让问题变得模糊(因为历史的分散性)了, Git 不会允许你 `push`. 你只能先合并远端最新的代码, 然后才能分享你的工作."
             ]
           }
         },
@@ -778,7 +778,7 @@ exports.level = {
               "废话说得真多, 看看实际案例吧!"
             ],
             "afterMarkdowns": [
-              "看见了吧? 什么都没有变, 命令失败了! `git push`的失败是因为你最新提交了`C3`(基于远端的`C1`). 而远端已经更新到了`C2`啦, 所以git 拒绝了你的push"
+              "看见了吧? 什么都没有变, 命令失败了! `git push` 的失败是因为你最新提交了 `C3` (基于远端的 `C1`). 而远端已经更新到了 `C2` 啦, 所以 Git 拒绝了你的 push"
             ],
             "command": "git push",
             "beforeCommand": "git clone; git fakeTeamwork; git commit"
@@ -813,7 +813,7 @@ exports.level = {
             "markdowns": [
               "还有其它的方法应对此种情况吗? 当然了, 我们还可以使用 `merge`",
               "",
-              "尽管`git merge`不会转移你的工作(相反的它会创建新的合并提交), 它会告诉git 你已经合并了远端的所有变更 -- 远端分支就是你自己分支的祖先, 这意味着, 你的提交反映了远端分支的提交.",
+              "尽管 `git merge` 不会转移你的工作(相反的它会创建新的合并提交), 它会告诉 Git 你已经合并了远端的所有变更 -- 远端分支就是你自己分支的祖先, 这意味着, 你的提交反映了远端分支的提交.",
               "",
               "看下演示..."
             ]
@@ -838,7 +838,7 @@ exports.level = {
             "markdowns": [
               "漂亮! 有更简单的命令吗?",
               "",
-              "当然 -- 就是你所知道`git pull`,  就是fetch 和merge 的简写. 更方便的 -- `git pull --rebase` 就是 fetch 和rebase的简写! ",
+              "当然 -- 就是你所知道的 `git pull`,  就是 fetch 和 merge 的简写. 更方便的 -- `git pull --rebase` 就是 fetch 和 rebase 的简写! ",
               "",
               "让我们看看简写命令是如何工作的."
             ]

src/levels/remote/pull.js

@@ -365,7 +365,7 @@ exports.level = {
               "如果使用 `git pull` 呢?"
             ],
             "afterMarkdowns": [
-              "同样的结果! 这清楚的说明了`git pull`就是git fetch再跟一个merge的缩写! "
+              "同样的结果! 这清楚地说明了 `git pull` 就是 git fetch 再跟一个 merge 的缩写! "
             ],
             "command": "git pull",
             "beforeCommand": "git clone; git commit; git fakeTeamwork"

src/levels/remote/pullArgs.js

@@ -413,7 +413,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "以下命令在 git 中是等价的:",
+              "以下命令在 Git 中是等价的:",
               "",
               "`git pull  origin foo` 相当于：",
               "",

src/levels/remote/push.js

@@ -248,7 +248,7 @@ exports.level = {
             "markdowns": [
               "## Git Push",
               "",
-              "太棒了, 我们已经学习了从远端获取|合并工作到我们的本地工作.但是我们如果分享工作呢?",
+              "太棒了, 我们已经学习了从远端获取/合并工作到我们的本地工作. 但是我们如果分享工作呢?",
               "",
               "好吧, 上载工作正好同下载工作相反, 那与 `git pull` 相反的命令是什么? `git push`! ",
               "",

src/levels/remote/pushArgs.js

@@ -401,7 +401,7 @@ exports.level = {
               "",
               "好! 既然你知道了远端跟踪分支, 我们可以开始揭开隐藏在 git push/pull/fetch 背后的秘密. ",
               "",
-              "首先看看`git push`, 在远端跟踪分支中, 你学到了git 会找出要push的目的地(通过查看检出的分支, 及分支关联到的跟踪分支). 这是无参数的行为, 不过我们也可以为push指定参数:",
+              "首先看看 `git push`, 在远端跟踪分支中, 你学到了 Git 会找出要 push 的目的地(通过查看检出的分支, 及分支关联到的跟踪分支). 这是无参数的行为, 不过我们也可以为 push 指定参数:",
               "",
               "`git push <remote> <place>`",
               "",
@@ -419,9 +419,9 @@ exports.level = {
               "",
               "* 切到 master 分支, 然后抓取所有的提交, 再将新提交推送到远端的 master 分支!",
               "",
-              "通过指定`master`为<place>参数, 我们告诉git 提交来自于master, 要推送到远端的master. 这种使用方式基本上用于同步两仓库",
+              "通过指定 `master` 为 <place> 参数, 我们告诉 Git 提交来自于 master, 要推送到远端的 master. 这种使用方式基本上用于同步两仓库",
               "",
-              "谨记, 因为我们通过指定参数告诉了git 所有的事, git 就忽略了我们所检出的分支(转而直接使用参数指定的分支作为source/destination)"
+              "谨记, 因为我们通过指定参数告诉了 Git 所有的事, Git 就忽略了我们所检出的分支(转而直接使用参数指定的分支作为 source/destination)"
             ]
           }
         },

src/levels/remote/pushArgs2.js

@@ -387,7 +387,7 @@ exports.level = {
               "",
               "你可能想知道 -- 如果来源和目的地不一样呢? ",
               "",
-              "好吧, 很不幸git 不可能做到... 只是个玩笑! 当然是可能的啦:)... git拥有超强的灵活性(几乎不能再多了) ",
+              "好吧, 很不幸 Git 不可能做到... 只是个玩笑! 当然是可能的啦 :) ... Git 拥有超强的灵活性(几乎不能再多了) ",
               "",
               "我们看看下一个幻灯片..."
             ]
@@ -401,7 +401,7 @@ exports.level = {
               "",
               "`git push origin <source>:<destination>`",
               "",
-              "这通常被称为<colon refspec>, refspec是一个奇特的名-- 用于git 能识别的位置(比如分支foo 或者 HEAD~1) ",
+              "这通常被称为 <colon refspec>, refspec 是一个奇特的名 -- 用于 Git 能识别的位置(比如分支 foo 或者 HEAD~1) ",
               "",
               "一旦你指定了独立的来源和目的地, 你就可以得到花哨而精确的远程命令, 让我们看看演示! "
             ]
@@ -411,10 +411,10 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "记住, `source` 是git 能理解的任何位置:"
+              "记住, `source` 是 Git 能理解的任何位置:"
             ],
             "afterMarkdowns": [
-              " 这是个很迷幻的命令, 但它是合理的 --  git 将foo^解析 为位置, 上传新提交到远端的目的地.  "
+              "这是个很迷幻的命令, 但它是合理的 -- Git 将 foo^ 解析为一个位置, 上传新提交到远端的目的地.  "
             ],
             "command": "git push origin foo^:master",
             "beforeCommand": "git clone; go -b foo; git commit; git commit"
@@ -424,7 +424,7 @@ exports.level = {
           "type": "GitDemonstrationView",
           "options": {
             "beforeMarkdowns": [
-              "如果你要push到的destination不存在呢? 没问题! git 会在远端为你创建这个分支!"
+              "如果你要 push 到的 destination 不存在呢? 没问题! Git 会在远端为你创建这个分支!"
             ],
             "afterMarkdowns": [
               "很赞吧! 干得漂亮! :D"

src/levels/remote/pushManyFeatures.js

@@ -389,7 +389,7 @@ exports.level = {
             "markdowns": [
               "本篇有点儿复杂 -- 以下是问题核心",
               "",
-              "* 这里有三个特性分支 -- `side1` `side2` and `side3`",
+              "* 这里有三个特性分支 -- `side1` `side2` 和 `side3`",
               "* 我需要按顺序将这三分支推送到远端.",
               "* 因为远端已经被更新过了, 所以我们需要先做合并!",
               "",

src/levels/remote/remoteBranches.js

@@ -427,7 +427,7 @@ exports.level = {
               "",
               "大多数的开发者会将它们的远端命名为 `origin`, 而非 `o`. 这是如此的普遍, 以致于当你用 `git clone` 时,得到的仓库名就是 `origin`",
               "",
-              "不幸的是, 我们的UI不适用`origin`, 我们使用缩写`o`, :) 记住, 当你使用真正的git时, 你的远程仓库很可能被命名为`origin`! ",
+              "不幸的是, 我们的UI不适用 `origin`, 我们使用缩写 `o`, :) 记住, 当你使用真正的 Git 时, 你的远程仓库很可能被命名为 `origin`! ",
               "",
               "说了这么多, 让我们看看实例."
             ]
@@ -440,7 +440,7 @@ exports.level = {
               "如果检出 remote 分支, 会发生什么呢?"
             ],
             "afterMarkdowns": [
-              "正如你所见, git 处于了分离`HEAD`, 当添加新的提交时, `o/master`不被更新, 这是因为`o/master` 仅伴随远端更新而更新."
+              "正如你所见, Git 处于了分离 `HEAD`, 当添加新的提交时, `o/master` 不被更新, 这是因为 `o/master` 仅伴随远端更新而更新."
             ],
             "command": "git checkout o/master; git commit",
             "beforeCommand": "git clone"

src/levels/remote/sourceNothing.js

@@ -296,7 +296,7 @@ exports.level = {
             "markdowns": [
               "### 奇葩的 `<source>`",
               "",
-              "有两种罕见的情况, git 不需要 `<source>`. 这基于这样一个事实-- 技术上说就是你不指定<source>. 这是通过空参数实现的",
+              "有两种罕见的情况, Git 不需要 `<source>`. 这基于这样一个事实 -- 技术上说就是你不指定 <source>. 这是通过空参数实现的",
               "",
               "* `git push origin :side`",
               "* `git fetch origin :bugFix`",
@@ -325,7 +325,7 @@ exports.level = {
               "如果给 fetch 传空 <source>, 那本地会创建一个新分支."
             ],
             "afterMarkdowns": [
-              "很神奇吧! 但无论怎么说, 这就是git !"
+              "很神奇吧! 但无论怎么说, 这就是 Git !"
             ],
             "command": "git fetch origin :bar",
             "beforeCommand": "git clone"

src/levels/remote/tracking.js

@@ -625,7 +625,7 @@ exports.level = {
             "markdowns": [
               "### Remote-Tracking branches",
               "",
-              "在前几节课程中有件事儿挺神奇的, git 好像知道`master`与`o/master`是相关的. 当然, 这些分支的名字是相同的, 所以可能是这种逻辑连接了远端的master分支和本地的master分支, 其实这种连接在以下两种情况下清楚体现: ",
+              "在前几节课程中有件事儿挺神奇的, Git 好像知道 `master` 与 `o/master` 是相关的. 当然, 这些分支的名字是相同的, 所以可能是这种逻辑连接了远端的 master 分支和本地的 master 分支, 其实这种连接在以下两种情况下清楚体现: ",
               "",
               "* pull 操作时, 我们下载提交到 o/master 并且合并到本地 master 分支。隐含的合并目标由此连接确定.",
               "* push 操作时, 我们把工作从 `master` 推到远端的 `master`(同时会更新远端的副本 `o/master`) 这个推送的目的地也是由这种连接确定的! ",
@@ -643,7 +643,7 @@ exports.level = {
               "",
               "你可能想知道这个属性是怎么被设定的? 你并没有用命令指定过这个属性呀! 好吧, 当你克隆仓库的时候, 这个属性就存在了. ",
               "",
-              "当你克隆时, git会创建跟踪分支(就像`o/master`), 对于每个远端分支, 创建一个跟踪远端分支的本地分支(`master`), 所以你经常会看到这个的命令输出:",
+              "当你克隆时, Git 会创建跟踪分支(就像 `o/master`), 对于每个远端分支, 创建一个跟踪远端分支的本地分支 (`master`), 所以你经常会看到这个的命令输出:",
               "",
               "    local branch \"master\" set to track remote branch \"o/master\"",
               ""

src/template.index.html

@@ -183,12 +183,14 @@
               </div>
             </div>
           </div>
+          <% if (title) { %>
             <div>
               <i class="icon-cog"></i>
               <span class="modal-title">
                 <%= title %>
               </span>
             </div>
+          <% } %>
         </div>
 
         <div class="inside">