Fix typographic quotation marks

stomar · stomar · commit beb57211b9a2 · 2016-08-07T11:36:08.000+02:00
diff --git a/en/documentation/faq/1/index.md b/en/documentation/faq/1/index.md
@@ -204,12 +204,12 @@ In mutt, you can get threading to work using the following variable setting.
 
 ### Which is correct, “Ruby” or “ruby”?
 
-Officially, the language is called ``Ruby''. On most systems, it is invoked
-using the command ``ruby''. It's OK to use ruby instead of Ruby.
+Officially, the language is called “Ruby”. On most systems, it is invoked
+using the command `ruby`. It's OK to use ruby instead of Ruby.
 
 Please don't use RUBY as the language name.
 
-Originally, or historically, it was called ``ruby''.
+Originally, or historically, it was called “ruby”.
 
 ### Are there any Ruby books?
 
@@ -219,14 +219,14 @@ October 2000.
 
 A Japanese language Ruby reference book by matz, et al and published by ASCII
 is available in Japan (ISBN 4-7561-3254-5). An English translation,
-`` The Ruby Programming Language,'' is in the works from Addison-Wesley
+“The Ruby Programming Language”, is in the works from Addison-Wesley
 (ISBN 020171096X).
 
-A Japanese language ``Ruby Pocket Reference'' is published by O'Reilly Japan
+A Japanese language “Ruby Pocket Reference” is published by O'Reilly Japan
 (ISBN 4-87311-023-8). Let O'Reilly in the US know if you'd like to see a
 translation.
 
-In addition, `` Mastering Regular Expressions,'' by Jeffrey Friedl, (the Hip
+In addition, “Mastering Regular Expressions”, by Jeffrey Friedl, (the Hip
 Owl Book): ISBN 1-56592-257-3 from O'Reilly & Associates, is a reference work
 that covers the art and implementation of regular expressions in various
 programming languages. Most of it is highly relevant to Ruby regular
diff --git a/en/documentation/faq/2/index.md b/en/documentation/faq/2/index.md
@@ -41,24 +41,24 @@ Python and Ruby are both object oriented languages that provide a smooth
 transition from procedural to OO programming styles. Smalltalk, by contrast,
 is object only - you can't do anything until you understand objects,
 inheritance and the sizable Smalltalk class hierarchy. By providing procedural
-training wheels, Python and Ruby ``fix'' one of the features that may have
+training wheels, Python and Ruby “fix” one of the features that may have
 kept Smalltalk out of the mainstream. The two languages differ by approaching
 this solution from opposite directions.
 
 Python is a hybrid language. It has functions for procedural programming and
 objects for OO programming. Python bridges the two worlds by allowing
-functions and methods to interconvert using the explicit ``self'' parameter
+functions and methods to interconvert using the explicit `self` parameter
 of every method def. When a function is inserted into an object, the first
 argument automagically becomes a reference to the receiver.
 
 Ruby is a pure OO language that can masquerade as a procedural one. It has no
-functions, only method calls. In a Ruby method the receiver, also called self,
-is a hidden argument like ``this'' in C++. A ``def'' statement outside of a
+functions, only method calls. In a Ruby method the receiver, also called `self`,
+is a hidden argument like `this` in C++. A `def` statement outside of a
 class definition, which is a function in Python, is actually a method call in
 Ruby. These ersatz functions become private methods of class Object, the root
 of the Ruby class hierarchy. Procedural programming is neatly solved from the
 other direction - everything is an object. If the user doesn't grok objects
-yet, they can just pretend that ``def'' is a function definition and still
+yet, they can just pretend that `def` is a function definition and still
 get useful work done.
 
 Ruby's OO purity provides a number features that Python lacks or is still
@@ -77,7 +77,7 @@ Python is sprouting (lambdas and list comprehensions).
 Ruby's syntax and design philosophy are heavily influenced by Perl. It has a
 lot of syntactic variability. Statement modifiers (if, unless, while, until,
 etc.) may appear at the end of any statement. Some key words are optional
-(the ``then'' in an ``if'' statement for example). Parentheses may sometimes
+(the `then` in an `if` statement for example). Parentheses may sometimes
 be elided in method calls. The receiver of a method may usually be elided.
 Many, many things are lifted directly from Perl.
 Built in regular expressions, $_ and friends, here documents,
diff --git a/en/documentation/faq/4/index.md b/en/documentation/faq/4/index.md
@@ -77,7 +77,7 @@ Produces:
 (Note that the class definition is executable code: the trace message it
 contains is written as the class is defined).
 
-A block (``{'' ... ``}'' or do ... end) almost introduces a new scope ;-)
+A block (`{ ... }` or `do ... end`) almost introduces a new scope ;-)
 Locals created within a block are not accessible outside the block. However,
 if a local within the block has the same name as an existing local variable
 in the caller's scope, then no new local is created, and you can subsequently
@@ -126,10 +126,10 @@ is a method and the associated block introduces a new scope.
 
 Actually, the question may be better asked as: "at what point does Ruby work
 out that something is a variable?" The problem arises because the simple
-expression ``a'' could be either a variable or a call to a method with no
+expression “a” could be either a variable or a call to a method with no
 parameters. To decide which is the case, Ruby looks for assignment statements.
-If at some point in the source prior to the use of ``a'' it sees it being
-assigned to, it decides to parse ``a'' as a variable, otherwise it treats it
+If at some point in the source prior to the use of “a” it sees it being
+assigned to, it decides to parse “a” as a variable, otherwise it treats it
 as a method. As a somewhat pathological case of this, consider this code
 fragment, submitted by Clemens Hintze:
 
@@ -153,10 +153,10 @@ Produces:
     Function 'a' called
     a=99
 
-During the parse, Ruby sees the use of ``a'' in the first print statement and,
-as it hasn't yet seen any assignment to ``a'', assumes that it is a method
+During the parse, Ruby sees the use of “a” in the first print statement and,
+as it hasn't yet seen any assignment to “a”, assumes that it is a method
 call. By the time it gets to the second print statement, though, it has seen
-an assignment, and so treats ``a'' as a variable.
+an assignment, and so treats “a” as a variable.
 
 Note that the assignment does not have to be executed---Ruby just has to have
 seen it. This program does not raise an error.
@@ -331,11 +331,11 @@ calls yield), or by using the Proc.call method.
     a                # -> "abcd"
     A                # -> "abcd"
 
-Variables hold references to objects. The assignment A = a = b = "abc" put a
-reference to the string ``abc'' into A, a, and b.
+Variables hold references to objects. The assignment A = a = b = "abc" puts a
+reference to the string “abc” into A, a, and b.
 
 When you called b.concat("d"), you invoked the concat method on that object,
-changing it from ``abc'' to ``abcd''. Because a and A also reference that
+changing it from “abc” to “abcd”. Because a and A also reference that
 same object, their apparent value changes too.
 
 This is less of a problem in practice than it might appear.
diff --git a/en/documentation/faq/6/index.md b/en/documentation/faq/6/index.md
@@ -39,7 +39,7 @@ header: |
 
 A colon followed by a name generates an integer(Fixnum) called a symbol
 which corresponds one to one with the identifier. "var".intern gives the
-same integer as :var, but the ``:'' form will create a local symbol if it
+same integer as :var, but the “:” form will create a local symbol if it
 doesn't already exist.
 
 The routines "catch", "throw", "autoload", and so on, require a string or a
diff --git a/en/documentation/faq/9/index.md b/en/documentation/faq/9/index.md
@@ -305,9 +305,9 @@ z
 
 9.16 What does "abcd"[0] return?
 
-It returns the character code for ``a'', 97(Fixnum). You can express a
+It returns the character code for “a”, 97 (Fixnum). You can express a
 character code as an integer constant by prefixing the character with a
-question mark, so ?a is also 97(Fixnum).
+question mark, so `?a` is also 97 (Fixnum).
 
 9.17 How can I expand tabs to spaces?
 
