Tutorial

Internationalization and Localization
in Ruby and Ruby on Rails

http://www.sw.it.aoyama.ac.jp/2015/pub/RubyRails/

IUC 39, Santa Clara, CA, U.S.A., 26 October 2015

Martin J. DÜRST

duerst@it.aoyama.ac.jp

© 2012-5 Martin J. Dürst, Aoyama Gakuin University

Overview and Introduction

Overview

• Introduction
• Ruby
• Strings and internationalization
• More about encodings
• Transcoding
• Encoding models
• Libraries
• Ruby on Rails

Introductions

• Audience:
  • Programming experience?
  • Programming with Ruby/Rails?
  • Internationalization/Globalization experience?
  • Unicode knowledge?
• Speaker:
  • Ruby committer since 2007
  • Contributed character transcoding
    and Unicode normalization
  • Long-time Unicode/W3C/IUC involvement

Goals

• Get started quickly
• Understanding concepts and model
• Understanding background
• Have fun

Conventions Used

• (Ruby) code is green, monospace:
  puts "Hello Ruby!"
• Variable parts are orange:
  puts "some string"
• Encoding are indicated with a _subscript:
  • "Юに코δ"_UTF-8
  • "ユニコード"_SJIS
• Results are indicated with "⇒": 1 + 1 ⇒ 2

Frequent Example Юに코δ

• Ю: Cyrillic uppercase YU
• に: Hiragana NI
• 코: Hangul KO
• δ: Greek delta

Ruby Basics

Ruby

• Created by Yukihiro Matsumoto (Matz; since 1993)
• Easy for beginners,
  deep for experts
• Object-oriented throughout, but not obtrusive
• Extremely flexible
• Particularly strong for (internal) DSLs and metaprogramming

Basic Ruby

5.times { puts "Hello Ruby!" }

• Everything is an object
• Methods can take blocks ({ ... } or do ... end)
• Unobtrusive syntax (no need for semicolons, ...)

Ruby Implementations

• MRI (Matz's Ruby Implementation), aka C-Ruby
  available on many platforms (download for Windows)
• JRuby: Ruby on the JVM
• Rubinius: Ruby (mostly) in Ruby
• RubyMotion: Ruby for IOS, Android, and MacOS
• IronRuby: Ruby on Microsoft CLR
• Opal: Ruby to JavaScript compiler
• A lot more ...

This tutorial is about MRI/C-Ruby, the reference implementation

Ruby Versions

• Ruby ≤1.8: RIP (Strings as byte sequences)
• Ruby 1.9 and later
• Ruby 2.0: UTF-8 default source encoding
• Ruby 2.2: Newest published version,
  Unicode normalization added (2014)
• Ruby 2.3: Release planned for Christmas 2015

A note about Ruby versions and Unicode versions: The Ruby core team is very conservative in introducing new Unicode versions as bug fixes. New versions therefore only get added on a minor version upgrade (e.g. 2.0, 2.1 (Unicode 6.0), 2.2 (Unicode 7.0), ...).

Up and Running

• Install Ruby
• Open a UTF-8 based console
  • Easy on Mac and Linux
  • On Windows: Cygwin Terminal, PuTTY, ...,
    or command prompt with chcp 65001
• Start irb (Interactive Ruby)
• Type in Ruby commands

Basic Ruby Internationalization

String Basics

• Strings are sequences of characters: (codepoints)
  "Юに코δ".length ⇒ 4
  

• We can get a byte count with:
  "Юに코δ".bytesize ⇒ 10

• They are instances of class String:
  "Юに코δ".class ⇒ String
• Characters are strings of size 1:
  "Юに코δ"[0] ⇒ "Ю";
  "Юに코δ"[0].length ⇒ 1

Using the same class for both strings and characters avoids the distinction between characters and strings of length 1. This matches Ruby's "big classes" policy. It also leaves the door open for 'characters' other than single codepoints. Strings are not Arrays, but where it makes sense, operations work the same for both classes. This is called duck typing.

Operations on Strings

Internationalized:

• Everything related to indexing
  e.g. [], reverse, ...
• Everything related to (strict) equality
  e.g. include?, index, ,...
• Everything using regular expressions
  e.g. match, sub, gsub, scan, split, tr, ...

Operations on Strings

Not yet internationalized:

• Casing: capitalize, downcase, ...
• Formating conversions: to_i, Int#to_s, ...
• Comparisons, sorting

Four Ways to Cut up Strings

Lines: "Unicode\nЮに코δ".lines.to_a
⇒ ["Unicode\n", "Юに코δ"]

Characters: "Юに코δ".chars.to_a
⇒ ["Ю", "に", "코", "δ"]

Codepoints: "Юに코δ".codepoints.map {|cp|
cp+1}.pack 'U*' ⇒ "Яぬ콕ε" (rotation by 1)

Bytes: "Юに코δ".bytes.inject {|m,b| m+b}
⇒ 1865 (sum of byte values)

each_line, each_char, each_codepoint, and each_byte are older names for lines, chars, codepoints, and bytes. The methods lines, chars, codepoints, and bytes return Enumerators. Here we just use to_a to produce arrays. Enumerators can be used directly for iteration with each, or with separate iterators for mapping with map, selection with select/reject.

The need for several enumerators on a single object was one of the main motivators for introducing enumerators into Ruby. This is an interesting example of how internationalization concerns can affect more 'fundamental' language features. The orthogonality resulting from separating what to enumerate over and how to iterate produces very expressive code.

Escaping Syntax

(all for "Юに코δ")

• Unicode escapes (\u):
  • Exactly four hex digits:
    "\u042e\u306b\ucf54\u03b4"
  • More or less than four hex digits:
    "\u{42e}\u{306b}\u{cf54}\u{3b4}"
  • Several characters in a row:
    "\u{42e 306b cf54 3b4}"
• Binary escapes:
  "\xD0\xAE\xE3\x81\xAB\xEC\xBD\x94\xCE\xB4"

Non-ASCII Identifiers

π = 3.14...

Possible, but not recommended (possible exceptions: basic education, special terminology)

Problems:

• In Ruby, constants and class names are UpperCase
• Many scripts don't have case distinctions
  → use C_class_name
• Ruby only treats ASCII uppercase as uppercase

Regular Expressions

• Onigmo: Very potent regular expression engine, forked from Oniguruma
• Literals: /.../options
• Implements character classes, scripts, and
  many other properties (see list of properties)
• Not fully compatible with UTS#18
  (Unicode Regular Expressions)

Regular Expression Details

UTS #18 recommends: \s, \p{space}, \p{Whitespace} → Unicode whitespace

In Ruby: \s → ASCII whitespace; \p{space}, \p{Whitespace} → Unicode whitespace

Examples:

"abc def" =~ /\s/ ⇒ 3 (i.e. found)
"abc\u00A0def" =~ /\s/ ⇒ nil
"abc\u00A0def" =~ /\p{space}/ ⇒ 3(i.e. found)
"abc\u00A0def" =~ /\p{Whitespace}/ ⇒ 3(i.e. found)

Keeping \s to mean ASCII whitespace only was done for backwards compatibility. This can be explained as follows: If somebody wrote a script doing some processing where they wanted to match ASCII whitespace characters, they used \s. If Ruby would change \s to suddenly match more characters than before, the meaning of that program would change. Maybe it would change just in the right way. But there's also a good chance that it will change in ways not intended by the programmer. (See also https://bugs.ruby-lang.org/issues/7154.)

Tips on Character Processing

• String indexing (e.g. "Юに코δ"[2]) and
  iterators (e.g. "Юに코δ".chars)
  are very slow because:
  • Many small objects get created
  • All code is in Ruby
• For speedup, use powerful, high-level operations
  (implemented in C)

Speedup with Hash, Regexp, and gsub

Example: Convert German to ASCII-only

1. Create Hash:
   german_hash = {'Ä'=>'Ae', 'ä'=>'ae',
'Ö'=>'Oe', 'ö'=>'oe', 'Ü'=>'Ue',
'ü'=>'ue', 'ß'=>'ss' }
2. Create regular expression:
   german_regexp = /[ÄäÖöÜüß]/
3. Use global substitution:
   my_german.gsub german_regexp, german_hash

Application of Speedup

• Implementation of normalization (NFC,...) in Ruby
• Regular expression for Normalization Runs created from Unicode data
• Hash dynamically updated for actual normalization patterns
• More than 100-fold speedup compared to naive implementation
• Beating Perl native (C only) implementation

See also: Implementing Normalization in Pure Ruby - the Fast and Easy Way, Martin J. Dürst, IUC 37, Santa Clara, Oct 2013

Character Encodings

Choices to Handle Other Encodings

1. Convert to/from UTF-8 on input/outpt
2. Work in other encoding throughout
   (helpful for quick scripts)
3. Work with multiple encodings internally
   (not recommended)

Transcoding on Input/Output

• File opening calls take encoding information
  "external": External encoding
  "external:internal": External and internal encoding
• Open file for reading:
  open('my_file.txt', 'r')
• As ISO-8859-1 (potentially no transcoding)
  open('my_file.txt', 'r:iso-8859-1')
• With transcoding
  open 'my_file.txt', 'r:KOI-8:SJIS'
• Encodings may be specified elsewhere
  (Caution: Explicit setting needed for stdin/out/err)

More Details about String

• Strings are instances of the String class
• Each String is:
  1. A sequence of characters
  2. Together with a character encoding
     (e.g.: US-ASCII, UTF-8, GB18030, ISO-8859-1, Shift_JIS,...)
     "Юに코δ".encoding.to_s ⇒ "UTF-8"
• Called the Character Set Independent (CSI) Model
• Fundamentally different from other programming languages

Java, JavaScript: UTF-16; Python: 8-bit/UTF-16/UTF-32; Perl: 8-bit/UTF-8; C/C++: mb/wc

Why CSI

• No information loss
• No unnecessary transcoding
• Early detection of encoding problems
• Mostly backwards compatible
• Simple things should stay simple

(Matz pushing for moving to UTF-8)

Other Objects with Encoding

• String: "Юに코δ"
• Symbol: :Юに코δ
• Regexp: /Юに코δ/
• Identifiers: Юに코δ

Setting an Encoding

(Very simplified, more details later)

• encode (actual transcoding):
  "abcδ".encode 'SJIS' ⇒ "abcδ"_SJIS
• force_encoding (change label, keep bytes):
  "abc\x83\xC2".force_encoding 'SJIS' ⇒ "abcδ"_SJIS

Unfortunately, force_encoding is destructive, no non-destructive equivalent.

Terminology: Transcoding

• String method: encode
  (Matz thought that transcode 'smells' of Video converters,...)
• Implementation: transcode.c,
  RUBYSOURCE/enc/trans
• Abstraction as object: Encoding::Converter (very rarely used)
• This tutorial: transcode

Encoding Clashes

"Юに코δ"_UTF-8 + "Юに코δ"_UTF-8
⇒ "Юに코δЮに코̃"_UTF-8

"Юに코δ"_UTF-8 + "Юに코δ"_UTF-16
⇒ Encoding::CompatibilityError

Other examples:
"Dürst"_ISO-8859-1 == "Dürst"_ISO-8859-2 ⇒ false

π_UTF-8 ≢ π_SJIS

Trying to combine strings with different encodings, as here with concatenation (+), leads to an exception. There are some exceptions (sic!) to this rule that we will look at later. The reasoning for the error here is that transcoding should not happen without the programmer being aware of it.

Trying to compare two character-by-character identical strings in different encodings will produce false, even if these strings are, as in the above example, also byte-for-byte identical. Again, the reason for the result is that encoding mismatches should be detected early. In addition, a simple byte-for-byte comparison could produce false positives.

Encodings

• Important Encodings
• Information about Encodings
• Properties of Encodings
• System Encodings

Important Encodings

In Ruby, all encodings are equal, but some encodings are more equal than others.

[Adapted from George Orwell's Animal Farm.]

The important encodings are:

• US-ASCII
• ASCII-8BIT (alias BINARY)
• UTF-8

US-ASCII Encoding

• LCD of most encodings
• Strictly 7-bit
• ASCII-only data

ASCII-Only Data

ASCII-only data very frequent in programs

Special treatment, to reduce errors and improve performance

This also makes it easy for programmers who don't think about encoding when working only with US-ASCII. Internally, Ruby caches whether a string is ASCII-only or not, to increase performance.

"Data"_SJIS.ascii_only? ⇒ true

"データ"_SJIS.ascii_only? ⇒ false

ASCII-only does not Clash

ASCII-only data does not cause Encoding::CompatibilityErrors,
even if encodings clash

"Юに코δ"_UTF-8 + "Data"_SJIS
⇒ "Юに코δData"_UTF-8

"Data"_SJIS + "Юに코δ"_UTF-8
⇒ "DataЮに코δ"_UTF-8

Similar behavior for other string operations

Testing for Clashes

Test with Encoding.compatible? st1, st2

Encoding.compatible? "Юに코δ"UTF-8, "Data"SJIS ⇒ UTF-8

ASCII-8BIT

Alias: BINARY

Used for binary data

Use when high-bit bytes' semantics are unknown (but 7-bit bytes are ASCII or can be treated as such)

Special shortcut (since Ruby 2.0):

string.b ≡
string.dup.force_encoding('ASCII-8BIT')

UTF-8

• Ruby's preferred encoding for Unicode
• \u escaping automatically makes strings UTF-8
• Dedicated command-line option: -U
• Default source encoding (since 2.0.0)
• Strong property support in regular expressions
• Support in Array#pack
• Many performance optimizations
• Pivot for encoding conversions
  (e.g. Shift_JIS → UTF-8 → KOI-8)

Encodings as Objects

String to encoding:
e = Encoding.find "WinDOwS-1252"

Encoding to string: e.to_s ⇒ "Windows-1252"

Methods most often accept both Strings and Encodings to indicate encodings

Constants for Encodings: Encoding::Windows_1252, Encoding::WINDOWS_1252

(We see that encoding names are case-insensitive, and are canonicalized. The internal canonicalization is specific to each encoding, and can start with a lower-case letter. Encodings are also exposed as constants in the Encoding module. There is always a constant with all letters in uppercase. There is also a constant that is the same or close to the internal canonical name, but starts with an uppercase letter. For the constants, hyphens are converted to underscores.)

Information about Encodings

List all encodings:

Encoding.list.join("\n")

Count the encodings supported:

Encoding.list.length

Ruby currently supports around 100 encodings

Encoding Aliases

Aliases are only separate names (not separate encodings)

To list all encoding names:
Encoding.name_list.join "\n"

To list all (active) aliases:
Encoding.aliases.each { |a, e|
puts "#{a} => #{e}" }

ASCII-Compatible Encodings

Most, but not all encodings are ASCII-compatible:
Encoding::UTF_8.ascii_compatible?
⇒ true
Encoding::UTF_16.ascii_compatible?
⇒ false

ASCII-compatible: ASCII characters≡ ASCII bytes
Encoding::Shift_JIS.ascii_compatible?
⇒ true
Encoding::ISO_2022_JP.ascii_compatible?
⇒ false

Non-ASCII-Compatible Encodings

List of non-ASCII-compatible encodings:

Encoding.list.reject &:ascii_compatible?

UTF-16BE, UTF-16LE, UTF-16
UTF-32BE, UTF-32LE, UTF-32
UTF-7
ISO-2022-JP, ISO-2022-JP-2, ISO-2022-JP-KDDI
CP50220, CP50221

Almost ASCII-Compatible Encodings

• Some encodings have some ASCII characters redefined
  e.g.: \x5C → ¥
• In Ruby, such redefinitions are ignored
  (but a font may still show 'as-if')
• Example: Some transcoding libraries distinguish Shift_JIS and Windows31J in this respect,
  but Ruby doesn't

Dummy Encodings

List of dummy encodings:

Encoding.list.select &:dummy?

UTF-16[LE|BE], UTF-32[LE|BE], UTF-7
ISO-2022-JP, ISO-2022-JP-2, ISO-2022-JP-KDDI
CP50220, CP50221

Dummy encodings are treated as opaque byte sequences

Dummy encodings are encodings which are treated as opaque byte sequences. But they are labeled, and may be transcoded to some other encodings.

Exceptional Encodings

• Fine distinctions:
  Shift_JIS vs. Windows31J
  (aka CP932 aka SJIS)
• For Emoji:
  UTF8-DoCoMo, UTF8-KDDI,
  UTF-SoftBank
• Stateless equivalents:
  stateless-ISO-2022-JP

System Encodings

• Source encoding
  
• Locale encoding
  
• External encoding
  
• Internal encoding
• Filename encoding

Source Encoding

• Indicate in comment on first line of source file:
  # ...coding: ISO-8859-1 ...
• More text allowed at ...
• Can be second line if first line is #!/usr/local/ruby
• Limited to ASCII-compatible (no EBCDIC, no UTF-16,...)
• UTF-8 is default since 2.0.0 (US-ASCII before)
• UTF-8 "BOM" also works

Locale Encoding

• Set from environment
• Queried with Encoding.locale_charmap

External encoding

• Used when reading in data
• Default is locale encoding
• Set with Encoding.default_external=(use sparingly!)
• Queried with Encoding.default_external

Internal encoding

• Used when reading in data
• Default is nil (i.e. unknown)
• Set with Encoding.default_internal=(use sparingly!)
• Queried with Encoding.default_internal 

Operations on IOs

• IO: Class for input and output (parent of File,...)
• external_encoding/internal_encoding
• set_encoding: changes external/internal encoding

Command-line Options

• -E, --encoding: Set default external or external:internal encoding
• -U: Set default internal encoding to UTF-8

Filesystem Encoding

• Represents encoding of file names in file system
• May be UTF-16 on Windows
• Otherwise, equal to locale encoding

Encoding Integrity Check

"abc\xFE"_UTF-8.valid_encoding? ⇒ false
"a\xC0\x80"_UTF-8.valid_encoding? ⇒ false
"abc\xC2\x80"_UTF-8.valid_encoding? ⇒ true
"abc\u03A2"_UTF-8.valid_encoding? ⇒ true(there is no uppercase final Sigma (yet!?))

Checks for code structure, not unassigned codepoints

How to Avoid Invalid Data

• For performance, Ruby checks encoding validity only when necessary
• Check on input (read)
• Transcode
  Caution: transcoding to same encoding is no-op,
  unless there's a fallback option
• Don't use low-level escapes and access methods

Transcoding Details

• String transcoding
• Transcoding options
• Failures and fallbacks
• Transcoding on input/output

Transcoding String to String

• "ユニコード"_SJIS.encode('UTF-8)
  ⇒ "ユニコード"_UTF-8
• Destructive equivalent: encode!

  string1 = "ユニコード"_SJIS

  string1.encode! 'UTF-8'

  string1 ⇒ "ユニコード"_UTF-8

Explicit to and from Encodings

Example: Force UTF-8 "double-encoding" (not recommended)

"Юに코δ"_UTF-8.force_encoding('iso-8859-1')
.encode('UTF-8')

⇒ "Юã\u0081«ì½\u0094δ"

Equivalent:

"Юに코δ"_UTF-8.encode('UTF-8', 'iso-8859-1')

Note order of arguments: to ← from

(I always disliked the order of arguments in iconv, but it was unavoidable here, because usually, just the 'to' encoding is needed, so that has to come first.)

Transcoding Failures

• Problem with input: Invalid byte sequence
  "abc\xFE"_UTF-8.encode 'SJIS' ⇒ Encoding::InvalidByteSequenceError
• Problem with output: Undefined conversion
  "Юに코δ"_UTF-8.encode 'SJIS' ⇒ Encoding::UndefinedConversionError

Fallback Options

• undef: What to do with undefined characters (:replace/:ignore(:ignore can lead to security issues!))
• invalid: What to do with invalid bytes (:replace/:ignore(:ignore can lead to security issues!))
• replace: String used as replacement
  (default: U+FFFD or '?')
• fallback: Object (e.g. Hash) used to look up replacement

Additional options for newline conversion and XML escaping

Adding an Encoding or Transcoding

• Encodings are added in RUBYSOURCE/enc
• Transcodings are added in
  RUBYSOURCE/enc/trans
• Start with an example close to what you need, and copy/modify
• Lists of encodings and transcodings are constructed automatically
  (see encdb.h, transdb.h)
• Contact me for advice,
  or to add your work to Ruby

Encoding Models

• Encoding Models for Applications
• Encoding Models for Libraries

Encoding Models for Applications

• Any single encoding
  
• One single encoding
  
• One single internal encoding
• Mixed Encodings
• others?

An encoding model describes which encoding(s) can be used in what part of an application (e.g. externally, internally). It defines the conditions and restrictions with respect to string processing that the application (programmer) has to maintain. When creating a Ruby application, it is important to choose the appropriate encoding model.

Any Single Encoding

• One run of application ⇔ one encoding
• Different runs may use different encodings
• On different systems, different encodings may be used (e.g. different Unix or Windows locales)
• Often assumes ASCII-compatible scripts, and works on ASCII parts only
• Suitable for simple scripts
• No declared source encoding
• Typical example: Replace some HTML/XML tags with others
• Advice: Okay as long as it doesn't hurt

One Single Encoding

• This is the simplest, and therefore highly preferable
• All of the application uses one single encoding
• Could be any encoding, but fixed when code created
• Assumptions about encoding hard-coded
• Preferably use UTF-8
• Example: New stand-alone application with i18n needs

For applications that use more character semantics outside the ASCII range, or that keep data for a long time, the ideal solution is to use only a single encoding. This should be UTF-8 because that covers all of Unicode and works best with Ruby.

One Single Internal Encoding

• Outside words has many encodings
• Inside, only a single encoding
• Conversion at boundaries
• Emulation of other (programming) languages' encoding models
• Use UTF-8 internally
• Advice: Realistic choice in many cases

If data (e.g. files) in other encodings also have to be handled, it will in most cases be best to adopt the model of most other programming languages: Use Unicode (i.e. UTF-8 for Ruby) inside, and convert on input/output.

Mixed Encodings

• Many encodings outside and inside
• Full power of Ruby encodings available
• Ruby takes care of bookkeeping
• Transcoding needs to be explicit
• Example: Decoding email messages
• Advice: Don't go there if you don't have to

Encoding Models for Libraries

• Operate on ASCII only, work on all ASCII-compatible encodings
• Operate on arbitrary single encodings
  Example: CSV standard library
• Use single encoding only, library user has to adapt
  E.g.: UTF-8

Important: Don't touch system encodings
(except maybe for a framework)

Libraries for Unicode Support

Ruby leaves open some important i18n support:

• Full case conversions
• Text segmentation,...

Various librairies are available for such tasks, mostly in the form of Ruby Gems

UnicodeUtils

• By Stefan Lang, in pure Ruby
• Ruby Gem, source on github
• Wide coverage of Unicode algorithms and data
• Highly fragmented
  • Good for memory saving
  • Needs lots of require statements
• Examples:
  require "unicode_utils/upcase"
UnicodeUtils.upcase("weiß")
  ⇒ "WEISS"
UnicodeUtils.upcase("i", :tr) ⇒ "İ"

Twitter_CLDR

• By Cameron Dutro, in pure Ruby
• Ruby Gem, source on github
• Number/date/... formatting
• Other CLDR support
• Other Unicode algorithm/data support
• Example:
  1337.32.localize(:es).to_s
  ⇒ "1.337,32"

ActiveSupport

• Toolbox used in different parts of Rails
• ActiveSupport::Multibyte
  • Chars class as wrapper for String
  • Grapheme Boundaries, case conversions,...
  • Strings-as-characters before Ruby 1.9

Ruby on Rails

• Revolutionary Web Framework (Revolutionary when it came out in 2004, now widely copied but still leading.)
• Extracted from Basecamp by David Heinemeier-Hansen (DHH)
• Overall structure: MVC
• Database-backed (ActiveRecord)
• Convention over Configuration

Rails and Encodings

• Uses UTF-8 out of the box
• Can use other encodings (but why would you)
• Make sure database is set up for UTF-8 before you start

Rails I18n Framework - Message Translation

• Replace texts: translate aka t
• Formatting data: localise aka l
• What language to use
• Where to store the translations (backend plugins)
• More information

Text Replacement: Templates

In templates, replace
<h1>Hello Rails!</h1>

with
<h1><%= t 'welcome.rails' %></h1>

welcome.rails is a structured key used for looking up the translated string

Tedious but simple!

Text Replacement: Backends

Where to get your text replacements from:

• Defaults (in config/locales):
  Ruby Hashes
  YAML files
• gettext
• SQL database
• ...

Locale Information

• Want to make sure user's choice is sticky
• Using cookies isn't RESTful
• Domain name, path part, or parameter is fine
• Setup using routes (mappings from URIs/IRIs to application parts)

Ongoing/Future Work

• Integration of more Unicode/Internationalization support into Ruby core
  
  • Unicode case conversion maybe for 2.3
• Automatic detection of localizable content in Rails templates
• Your idea/contribution here!

Q & A

Send questions and comments to Martin Dürst, duerst@it.aoyama.ac.jp

The latest version of this tutorial is available at:

http://www.sw.it.aoyama.ac.jp/2015/pub/RubyRails/