Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

&block syntax, Blocks As Dynamic Callbacks
using with instance_eval( ), Blocks for Interface Simplification
* (array splat operator), Designing for Convenience: Ruport’s Table() feature
*args idiom, Treating Arguments As an Array
<=> (spaceship) operator, Make Use of Custom Operators

A

ActiveRecord, object-relational mapping (ORM), Exclamation points
activesupport gem
test( ) method, Designing for Testability
Adobe Font Metrics file, parser for, Text Processing and File Management–Line-Based File Processing with State Tracking
aliasing
aliases, collisions in, Modification via Aliasing
alias_method( ), Modification via Aliasing
modification via, Modification via Aliasing–Modification via Aliasing
anchors in regular expressions, Anchors Are Your Friends
anonymous classes
defined, Building Classes and Modules Programmatically
generation by calls to Class.new( ), Building Classes and Modules Programmatically
looking up by extension name, Building Classes and Modules Programmatically
APIs, designing, Designing Beautiful APIs–Conclusions
avoiding surprises, Avoiding Surprises–Make Use of Custom Operators
method? and method!, Understand What method? and method! Mean–Exclamation points
summary of practices, Make Use of Custom Operators
using attr_reader, attr_writer, and attr_accessor, Use attr_reader, attr_writer, and attr_accessor–Use attr_reader, attr_writer, and attr_accessor
using custom operators, Make Use of Custom Operators
designing for convenience, Ruport Table( ) method, Designing for Convenience: Ruport’s Table() feature–Designing for Convenience: Ruport’s Table() feature
flexible argument processing, Ruby’s Secret Power: Flexible Argument Processing–Treating Arguments As an Array
guidelines for design of methods, Treating Arguments As an Array
using code blocks, Ruby’s Other Secret Power: Code Blocks–Blocks for Interface Simplification
append operator, Make Use of Custom Operators
argument processing, flexible, Ruby’s Secret Power: Flexible Argument Processing–Treating Arguments As an Array
ordinal arguments with optional parameters, Ordinal Arguments with Optional Parameters
pseudo-keyword arguments, Ordinal Arguments with Optional Parameters
standard ordinal arguments, Standard Ordinal Arguments
treating arguments as an array, Pseudo-Keyword Arguments–Treating Arguments As an Array
arguments
block, Block Arguments
multisplat, Multisplat Arguments
array splat operator (*), Designing for Convenience: Ruport’s Table() feature
Array#each method, Working with Enumerable
arrays
adding elements to end of, Minimizing Mutable State and Reducing Side Effects
parsing, Lexical Parsing with Regular Expressions (strscan)
treating arguments as, Pseudo-Keyword Arguments–Treating Arguments As an Array
using for caching in memoization, Memoization
ASCII strings, transcoding and, Transcoding User Input in an Organized Fashion
assertions, custom, building for testing, Custom Assertions
assert_block( ) function, using to build custom assertions, Custom Assertions
assert_equal( ) method, Lexical Parsing with Regular Expressions (strscan)
assert_nothing_raised( ) method, Testing Exceptions
assert_raises( ) method, Testing Exceptions
attribute writers in instance_eval-based interfaces, Dual-Purpose Accessors
attr_reader, attr_writer, and attr_accessor, Use attr_reader, attr_writer, and attr_accessor–Use attr_reader, attr_writer, and attr_accessor
authentication
HTTP, Working with HTTP and FTP (open-uri)
LDAP authentication module, Modular Code Organization
automated behavior verification, Designing for Testability

B

backward-compatible code, extension files for, Laying Out Your Library
backward-compatible code, writing, Writing Backward-Compatible Code–Conclusions
compatibility shims for common operations, Compatibility Shims for Common Operations
nonportable features in Ruby 1.9, Nonportable Features in Ruby 1.9–Oniguruma
block arguments, Block Arguments
block-local variables, Block-Local Variables
m17n functionality, Most m17n Functionality
multisplat arguments, Multisplat Arguments
new Proc syntax, New Proc Syntax
Oniguruma, Oniguruma
pseudo-keyword hash syntax, Pseudo-Keyword Hash Syntax
selective backporting, Selective Backporting
version-specific code blocks, Version-Specific Code Blocks
workarounds for common issues, Workarounds for Common Issues
character operations, Character Operations
encoding conversions, Encoding Conversions
String iterators, String Iterators
using Enumerator, Using Enumerator
BasicObject class, instance methods, BlankSlate: A BasicObject on Steroids
BasicObject objects, BlankSlate: A BasicObject on Steroids
begin…rescue construct, Finding Needles in a Haystack
binary files, character encodings and, Working with Files
binding data to a template, Embedded Ruby for Code Generation (erb)
Blaag::Entry objects, Embedded Ruby for Code Generation (erb)
BlankSlate class, Mastering the Dynamic Toolkit–BlankSlate: A BasicObject on Steroids, Registering Hooks and Callbacks
core implementation, BlankSlate: A BasicObject on Steroids
find_hidden_method( ) helper function, BlankSlate: A BasicObject on Steroids
hide( ) method, BlankSlate: A BasicObject on Steroids
hiding and restoring functionality, BlankSlate: A BasicObject on Steroids
hook watching for and hiding newly defined methods, Detecting Newly Added Functionality
interesting features, BlankSlate: A BasicObject on Steroids
block arguments, Block Arguments
block-local variables, Block-Local Variables
builder gem, BlankSlate: A BasicObject on Steroids
Builder::XmlMarkup, BlankSlate: A BasicObject on Steroids

C

caching
function return values via memoization, Memoization
Memoizable module approach versus manual caching, Memoization
:call-seq: directive, Controlling Output with RDoc Directives
callbacks, Registering Hooks and Callbacks
(see also hooks, registering)
blocks as dynamic callbacks, Blocks As Dynamic Callbacks–Blocks As Dynamic Callbacks
Camping module, Building Classes and Modules Programmatically
approximation of routing magic, Conclusions
Cell objects, Laziness Can Be a Virtue (A Look at lazy.rb)–Laziness Can Be a Virtue (A Look at lazy.rb)
Cell#height method, Laziness Can Be a Virtue (A Look at lazy.rb)
Cell#width method, Laziness Can Be a Virtue (A Look at lazy.rb)
character classes in regular expressions, Don’t Work Too Hard
character encodings
conversions, Encoding Conversions
multibyte, m17n-Safe Low-Level Text Processing
parsing in CSV library, m17n by Example: A Look at Ruby’s CSV Standard Library
setting source encodings, Source Encodings
UTF-8, m17n by Example: A Look at Ruby’s CSV Standard Library
character operations, Character Operations
character sets, Reducing Cultural Barriers
checksums, Cryptographic Hash Functions (digest)
Chinese translations for RPS application, Localizing Your Code
class << obj; notation, Implementing Per-Object Behavior, Implementing Per-Object Behavior
class variables, Class Variables Considered Harmful–Class Variables Considered Harmful
Class#inherited hook, Tracking Inheritance
Class.new( ) method, Building Classes and Modules Programmatically
classes
building programmatically, Building Classes and Modules Programmatically–Building Classes and Modules Programmatically
tips for, Building Classes and Modules Programmatically
encapsulation of code, Modular Code Organization
extending existing Ruby classes, Adding New Functionality–Adding New Functionality
open class system, Extending and Modifying Preexisting Code
closures, Making instance_eval() Optional, Implementing Per-Object Behavior
using functions to build custom procedures on the fly, Higher-Order Procedures
code blocks, Ruby’s Other Secret Power: Code Blocks–Blocks for Interface Simplification
as dynamic callbacks, Blocks As Dynamic Callbacks–Blocks As Dynamic Callbacks
guidelines for using in API design, Blocks for Interface Simplification
using for interface simplification, Blocks for Interface Simplification
using to abstract pre- and postprocessing, Using Blocks to Abstract Pre- and Postprocessing–Using Blocks to Abstract Pre- and Postprocessing
working with Enumerable, Ruby’s Other Secret Power: Code Blocks
code generation with Embedded Ruby (erb), Embedded Ruby for Code Generation (erb)–Embedded Ruby for Code Generation (erb)
collision, risk with hashing algorithms, Cryptographic Hash Functions (digest)
comments in source code for documentation, Basic Documentation Techniques and Guidelines, Basic Documentation Techniques and Guidelines
Comparable module, Make Use of Custom Operators
conditional statements, methods ending in ?, Question marks
controllers handling URL routing, Building Classes and Modules Programmatically
cryptographic hash functions (digest), Cryptographic Hash Functions (digest)–Cryptographic Hash Functions (digest)
CSV (comma-separated-value) files, Working with Tabular Data (csv)
csv standard library, Working with Tabular Data (csv)–Working with Tabular Data (csv)
m17n (multilingualization) by example, m17n by Example: A Look at Ruby’s CSV Standard Library–m17n by Example: A Look at Ruby’s CSV Standard Library
reading files, Working with Tabular Data (csv)
writing summary report from CSV file, Working with Tabular Data (csv)
CSV.open method, Working with Tabular Data (csv)
CSV::Row, Working with Tabular Data (csv)

D

Date objects, Working with Dates and Times (date)
date standard library, Working with Dates and Times (date)–Working with Dates and Times (date)
Date.strptime method, Working with Dates and Times (date)
DateTime objects, Working with Dates and Times (date)
DateTime.parse method, Working with Dates and Times (date)
debugging, When Things Go Wrong–Conclusions
coding failing test to reproduce problem, Capturing the Essence of a Defect
converting simplified example to part of automated test suite, Capturing the Essence of a Defect
procedure for, A Process for Debugging Ruby Code
process for, A Process for Debugging Ruby Code–A Process for Debugging Ruby Code
producing reduced example of defect, Capturing the Essence of a Defect–Capturing the Essence of a Defect
scrutinizing code, Scrutinizing Your Code–Finding Needles in a Haystack
using logger, Working with Logger–Working with Logger
writing test case, A Process for Debugging Ruby Code
default_external encoding, Working with Files, Customizing Encoding Defaults
default_internal encoding, Customizing Encoding Defaults
define_method( ), BlankSlate: A BasicObject on Steroids, BlankSlate: A BasicObject on Steroids
(see also BlankSlate class)
closure block passed to, Implementing Per-Object Behavior
dependencies, Laying Out Your Library
on external code and resources, removing, Using Mocks and Stubs
on external resources, avoiding by using mock objects, Run the Whole Suite at Once
working with in RubyGems, Working with Dependencies–Working with Dependencies
designing APIs (see APIs, designing)
destructive operations, Exclamation points
development dependencies, Working with Dependencies
digest standard library, Cryptographic Hash Functions (digest)–Cryptographic Hash Functions (digest)
Digest::MD5, Cryptographic Hash Functions (digest), Cryptographic Hash Functions (digest)
Digest::SHA1, Cryptographic Hash Functions (digest), Cryptographic Hash Functions (digest)
Digest::SHA256, Cryptographic Hash Functions (digest), Cryptographic Hash Functions (digest)
digitally signed file downloads, Cryptographic Hash Functions (digest)
directories, temporary, Automatic Temporary Directory Handling
directory layout, running tests on entire suite, Run the Whole Suite at Once
display_events_at function, Working with Dates and Times (date)
documentation, Exploring a Well-Organized Ruby Project (Haml), API Documentation via RDoc–Controlling Output with RDoc Directives
(see also RDoc)
API documentation via RDOC, Controlling Output with RDoc Directives
autogenerated API documentation, Exploring a Well-Organized Ruby Project (Haml), Exploring a Well-Organized Ruby Project (Haml)
basic techniques and guidelines, Basic Documentation Techniques and Guidelines–Basic Documentation Techniques and Guidelines
RDoc generated directly from source, Exploring a Well-Organized Ruby Project (Haml)
summary of key points, Controlling Output with RDoc Directives
domain-specific interfaces, building flexible, Building Flexible Interfaces–Dual-Purpose Accessors
dual-purpose accessors, Dual-Purpose Accessors
guidelines for design, Dual-Purpose Accessors
handling messages with method_missing( ) and send( ), Handling Messages with method_missing() and send()–Handling Messages with method_missing() and send()
making instance_eval( ) optional, Making instance_eval() Optional–Making instance_eval() Optional

E

edge cases for a method, writing example to test, Well-Focused Examples
Embedded Ruby (ERB), Embedded Ruby for Code Generation (erb)
embedding tests in library files, Embedding Tests in Library Files
encapsulation of code, module mixin capability and, Modular Code Organization
encode_str( ) method, m17n-Safe Low-Level Text Processing
Encoding objects, m17n by Example: A Look at Ruby’s CSV Standard Library
Enumerable module, Ruby’s Other Secret Power: Code Blocks
included into class as mixin, Modular Code Organization
Enumerable objects, filtering with, Higher-Order Procedures
Enumerable#all? method, A Process for Debugging Ruby Code
Enumerable#inject method, Minimizing Mutable State and Reducing Side Effects
Enumerable#map method, Minimizing Mutable State and Reducing Side Effects
Enumerable#with_index, Finding Needles in a Haystack
Enumerator objects
backward-compatible code, Using Enumerator
using in file line-by-line processing, Using Enumerator
erb (Embedded Ruby) standard library, Embedded Ruby for Code Generation (erb)–Embedded Ruby for Code Generation (erb)
ERB templates
creating, Embedded Ruby for Code Generation (erb)
for Rock, Paper, Scissors game views, Localizing Your Code
ERB#result method, Embedded Ruby for Code Generation (erb)
ERB.new method, Embedded Ruby for Code Generation (erb)
ERROR logging level, Working with Logger
error logging, comprehensive, Working with Logger–Working with Logger
errors, reraising, Finding Needles in a Haystack
escaping special characters in regular expressions, m17n by Example: A Look at Ruby’s CSV Standard Library
eval( ) method, evils of, The Evils of eval()–The Evils of eval()
EvenSeries module, Infinite Lists
EvenSeries::Node, Infinite Lists
event scheduling, Working with Dates and Times (date)
selective retrieval and display of events, Working with Dates and Times (date)
events_at method, Working with Dates and Times (date)
examples (in projects), Examples–Examples
exceptions
rescuing, Blind Rescue Missions–Blind Rescue Missions
testing, Testing Exceptions
executables, Executables
RubyGems, Writing a Gem::Specification
extend( ) method, Tracking Mixins
using in per-object modification, Per-Object Modification
extending and modifying existing code, Extending and Modifying Preexisting Code–Per-Object Modification
adding new functionality, Adding New Functionality–Adding New Functionality
modification via aliasing, Modification via Aliasing–Modification via Aliasing
per-object modification, Per-Object Modification
summary of key points, Per-Object Modification
extension files, Laying Out Your Library, Laying Out Your Library
Prawn, Selective Backporting
external character encoding for files, Working with Files

F

faker gem, Finding Needles in a Haystack
fastercsv gem, Working with Tabular Data (csv)
FATAL logging level, Working with Logger
Fatty, Ruport 2.0, Building Classes and Modules Programmatically
Fatty::Formatter class, Building Classes and Modules Programmatically
Fibonacci sequence, computing with recursive function, Memoization
file management, Line-Based File Processing with State Tracking, Working with Files
(see also text processing)
atomic saves, Atomic Saves
guidelines for, Atomic Saves
key points of working with filesystem and temp files, Automatic Unlinking
using Pathname and FileUtils, Using Pathname and FileUtils–Using Pathname and FileUtils
using tempfile standard library, The tempfile Standard Library–Automatic Unlinking
File#lineno method, Tracking line numbers
File.binread( ) method, Working with Files, Compatibility Shims for Common Operations
File.foreach( ) method, Using Enumerator
File.open( ) and File.read( ), character encodings and, Working with Files
File.read_binary method, Compatibility Shims for Common Operations
files, character encodings, Working with Files
fileutils standard library, Using Pathname and FileUtils
using for atomic saves, Atomic Saves
filtering
Filter objects doing some work in SQL and rest in Ruby, Higher-Order Procedures
using lazy stream, Infinite Lists, Infinite Lists
flexmock gem, Using Mocks and Stubs
testing IO objects and operations, Using Mocks and Stubs
foo.rb, running to execute tests, Embedding Tests in Library Files
format( ) method, Building Classes and Modules Programmatically
French translation for RPS game, Localizing Your Code
FTP, working with, using open-uri, Working with HTTP and FTP (open-uri)
functions
caching return values via memoization, Memoization
collection unified under single namespace, Modular Code Organization
documentation, Basic Documentation Techniques and Guidelines
groupings of, Ruby modules and, Modular Code Organization
higher-order, Higher-Order Procedures
well-defined, Memoization

G

gem specification (gemspec), Writing a Gem::Specification–Writing a Gem::Specification
dependencies, Working with Dependencies–Working with Dependencies
gems, building standalone, Writing a Gem::Specification
Gibberish plug-in, Localizing Your Code
Gibberish::Simple module, Localizing Your Code
git revision control system, Cryptographic Hash Functions (digest)
Gray, James Edward, II, Memoization, Infinite Lists
greedy quantifiers, Use Caution When Working with Quantifiers
grouping-and-summing operation, Working with Tabular Data (csv)
GSearch.show_results method, Human-Readable Data Serialization (json)

H

Haml project, Exploring a Well-Organized Ruby Project (Haml)–Exploring a Well-Organized Ruby Project (Haml)
autogenerated API documentation, Exploring a Well-Organized Ruby Project (Haml)
gem specification (gemspec), Writing a Gem::Specification–Writing a Gem::Specification
Haml::Engine object and documentation, Exploring a Well-Organized Ruby Project (Haml)
library layout, Exploring a Well-Organized Ruby Project (Haml)
rake install task, installing Haml as gem, Exploring a Well-Organized Ruby Project (Haml)
Rake::GemPackageTask, Exploring a Well-Organized Ruby Project (Haml)
Rake::RDocTask, Rake: Ruby’s Built-in Build Utility
README file, Exploring a Well-Organized Ruby Project (Haml)
tests describing how code is to be used, Exploring a Well-Organized Ruby Project (Haml)
verifying successful completion of tests, Exploring a Well-Organized Ruby Project (Haml)
zipped archives, Exploring a Well-Organized Ruby Project (Haml)
Hash objects, using for caching, Memoization–Memoization
Hash#each method, Working with Enumerable
Hash#keys method, Human-Readable Data Serialization (json)
Hash.new method, Memoization
hashes
option hashes, forwarding, Designing for Convenience: Ruport’s Table() feature
pseudo-keyword arguments, Pseudo-Keyword Arguments
helper functions for testing, Test Helpers
hexdigest( ) method, Cryptographic Hash Functions (digest)
calling on Digest::MD5, Cryptographic Hash Functions (digest)
calling on Digest::SHA1, Cryptographic Hash Functions (digest)
calling on Digest::SHA256, Cryptographic Hash Functions (digest)
hooks, registering, Registering Hooks and Callbacks–Tracking Mixins
detecting newly added functionality, Detecting Newly Added Functionality–Detecting Newly Added Functionality
tracking inheritance, Tracking Inheritance–Tracking Inheritance
tracking mixins, Tracking Mixins–Tracking Mixins
HTML templating with ERB, Embedded Ruby for Code Generation (erb)
HTTP, working with, using open-uri, Working with HTTP and FTP (open-uri)

I

images, embedding in PDF documents, Cryptographic Hash Functions (digest)
include( ) method, Tracking Mixins
infinite lists, Infinite Lists–Infinite Lists
building up recursively using lazy_stream, Infinite Lists
creating custom LazyStream::Node objects, Infinite Lists
object representing even sequence of numbers, Infinite Lists
summary of important concepts, Infinite Lists
using filters and transforms with lazy_stream, Infinite Lists
using LazyStream::Node objects to create step iterator, Infinite Lists
using lazy_stream.rb to iterate over range of numbers, Infinite Lists
INFO logging level, Working with Logger
inheritance
restrictive, When Inheritance Becomes Restrictive–When Inheritance Becomes Restrictive
tracking, Tracking Inheritance–Tracking Inheritance
inline styling, Designing for Testability
input and output
network I/O via sockets, Using Blocks to Abstract Pre- and Postprocessing–Using Blocks to Abstract Pre- and Postprocessing
temporary files, Same Old I/O Operations
testing complex output, Testing Complex Output–Testing Complex Output
using StringIO as mock for IO objects, Using Mocks and Stubs
inspect output, improving, Improving inspect Output
InspectTemplate module, Improving inspect Output
install instructions, What Goes in a README
instance_eval( ) method, BlankSlate: A BasicObject on Steroids
interfaces based on, attribute writers and, Dual-Purpose Accessors
making optional, Making instance_eval() Optional–Making instance_eval() Optional
using with &block syntax, Blocks for Interface Simplification
instance_methods( ), BlankSlate: A BasicObject on Steroids
instance_variable_get( ) function, Utilizing Reflection
integer division, Mathematical Ruby Scripts (mathn)
iterative design, Designing for Testability
iterators
blocks as, Ruby’s Other Secret Power: Code Blocks
building custom, Working with Enumerable

J

JSON (JavaScript Object Notation), Human-Readable Data Serialization (json)
converting JSON to Ruby, Human-Readable Data Serialization (json)
converting parsed JSON into custom higher-level Ruby object, Human-Readable Data Serialization (json)
parsing, Lexical Parsing with Regular Expressions (strscan)
primitive constructs provided by, Human-Readable Data Serialization (json)
producing, using your custom objects, Human-Readable Data Serialization (json)
JSON array, starting and end points, Lexical Parsing with Regular Expressions (strscan)
json standard library, Human-Readable Data Serialization (json)–Human-Readable Data Serialization (json)
json_class attribute, Human-Readable Data Serialization (json)
json_create method, Human-Readable Data Serialization (json)

K

kcode system, Customizing Encoding Defaults
Kernel module, Detecting Newly Added Functionality
Kernel#gem method, Working with Dependencies
Kernel#open, patching to accept URIs, Working with HTTP and FTP (open-uri)
Kernel#p method, Utilizing Reflection
improving output, Improving inspect Output
Kernel#require method, Modification via Aliasing
Kernel#y method, Improving inspect Output
keyword arguments, Ruby and, Pseudo-Keyword Arguments
—Ku flag, Customizing Encoding Defaults

L

L10n (localization), Reducing Cultural Barriers, Localizing Your Code–Localizing Your Code
dealing with names of people, Localizing Your Code
doing as late as possible to avoid effects on business logic, Localizing Your Code
guidelines for, Localizing Your Code
localized version of Rock, Paper, Scissors game, Localizing Your Code
passing all strings shown to viewer through translation filter, Localizing Your Code
view level localization of Rock, Paper, Scissors game, Localizing Your Code
writing helper functions for translation, Localizing Your Code
LANG environment variable, Inferring Encodings from Locale
Latin-1 (ISO-8859-1) encoding, Working with Files
lazy evaluation, Laziness Can Be a Virtue (A Look at lazy.rb)–Laziness Can Be a Virtue (A Look at lazy.rb)
Cell objects, Laziness Can Be a Virtue (A Look at lazy.rb)
infinite lists, Infinite Lists
Proc objects, Laziness Can Be a Virtue (A Look at lazy.rb)
summary of key points, Laziness Can Be a Virtue (A Look at lazy.rb)
lazy streams, Infinite Lists
lazy.rb, Laziness Can Be a Virtue (A Look at lazy.rb)–Laziness Can Be a Virtue (A Look at lazy.rb)
Lazy::Promise objects, Laziness Can Be a Virtue (A Look at lazy.rb)
implementing in Ruby 1.9, Laziness Can Be a Virtue (A Look at lazy.rb)
use of method_missing, Laziness Can Be a Virtue (A Look at lazy.rb)
LazyStream module, Infinite Lists
LazyStream::Node
building infinite list recursively, Infinite Lists
constructing simple step iterator, Infinite Lists
creating custom objects, Infinite Lists
lazy_stream.rb, Infinite Lists
library files in projects, directory and file structure, Laying Out Your Library–Laying Out Your Library
library files, embedding tests in, Embedding Tests in Library Files
loadpath for examples, Examples
locale, inferring encodings from, Inferring Encodings from Locale
localization (see L10n)
logger standard library, Working with Logger–Working with Logger
logging
guidelines for, Working with Logger
INFO and ERROR levels, Working with Logger

M

m17n (multilingualization), Reducing Cultural Barriers
examples in CSV standard library, m17n by Example: A Look at Ruby’s CSV Standard Library–m17n by Example: A Look at Ruby’s CSV Standard Library
portable m17n through UTF-8 transcoding, Portable m17n Through UTF-8 Transcoding–Transcoding User Input in an Organized Fashion
guidelines for, Transcoding User Input in an Organized Fashion
source encodings, Source Encodings
transcoding user input, Transcoding User Input in an Organized Fashion–Transcoding User Input in an Organized Fashion
working with files, Working with Files
Ruby 1.8 and, Most m17n Functionality
safe, low-level text processing, m17n-Safe Low-Level Text Processing–m17n-Safe Low-Level Text Processing
in standalone scripts, m17n in Standalone Scripts–Customizing Encoding Defaults
customizing encoding defaults, Customizing Encoding Defaults
guidelines for, Customizing Encoding Defaults
inferring encodings from locale, Inferring Encodings from Locale
Math module, Modular Code Organization, Mathematical Ruby Scripts (mathn)
mathn standard library, Mathematical Ruby Scripts (mathn)–Mathematical Ruby Scripts (mathn)
Matrix class, Mathematical Ruby Scripts (mathn)
MD5 checksums, using to check for changes in data, Transactional Filesystem-Based Data Storage (pstore)
MD5 hashes, Cryptographic Hash Functions (digest)
Memoizable module, Memoization
full implementation, Memoization
memoize( ) method, Memoization
performance, manual caching versus, Memoization
memoization, Memoization–Memoization
defined, Memoization
performance, caching using Memoizable versus manual caching, Memoization
summary of important concepts, Memoization
using Hash objects for caching, Memoization–Memoization
MenTaLguY, lazy.rb, Laziness Can Be a Virtue (A Look at lazy.rb)–Laziness Can Be a Virtue (A Look at lazy.rb)
messages, handling with method_missing( ) and send( ), Handling Messages with method_missing() and send()–Handling Messages with method_missing() and send()
method? and method!, Understand What method? and method! Mean
methods
documentation, Basic Documentation Techniques and Guidelines
flexible argument processing, Ruby’s Secret Power: Flexible Argument Processing–Treating Arguments As an Array
question mark (?) and exclamation point (!) at end of names, Understand What method? and method! Mean–Exclamation points
using code blocks to abstract pre- and postprocessing, Using Blocks to Abstract Pre- and Postprocessing–Using Blocks to Abstract Pre- and Postprocessing
method_added( ) function, Detecting Newly Added Functionality
method_missing( ) method, Handling Messages with method_missing() and send()
done wrong, Doing method_missing Wrong–Doing method_missing Wrong
use by Lazy::Promise, Laziness Can Be a Virtue (A Look at lazy.rb)
minitest/unit library, A Quick Note on Testing Frameworks
mock objects
avoiding external resource dependencies, Run the Whole Suite at Once
costs of using, Using Mocks and Stubs
StringIO class as, Using Mocks and Stubs
summary of functionality, Using Mocks and Stubs
uses of, Testing Complex Output
modular code organization, Modular Code Organization–Modular Code Organization
code encapsulation and classes, Modular Code Organization
collection of functions under single namespace, Modular Code Organization
executing functions on a module, Modular Code Organization
extending a module with itself, Modular Code Organization
guidelines for use, Modular Code Organization
module included into class as mixin, Modular Code Organization
modules
building programmatically, Building Classes and Modules Programmatically–Building Classes and Modules Programmatically
tips for, Building Classes and Modules Programmatically
included in objects at runtime, Detecting Newly Added Functionality
tracking mixins, Tracking Mixins–Tracking Mixins
module_function, Modular Code Organization
mooch script, Using Pathname and FileUtils
multibyte character encodings, m17n-Safe Low-Level Text Processing
multilingualization (see m17n)
multisplat arguments, Multisplat Arguments
mutable state, minimizing, and reducing side effects, Minimizing Mutable State and Reducing Side Effects–Minimizing Mutable State and Reducing Side Effects
code free of side effects, Minimizing Mutable State and Reducing Side Effects
guidelines for, Minimizing Mutable State and Reducing Side Effects
recursive solution, Minimizing Mutable State and Reducing Side Effects
rewriting naive_map to be stateless, Minimizing Mutable State and Reducing Side Effects
rewriting recursive solution iteratively, Minimizing Mutable State and Reducing Side Effects
using Enumerable#inject instead of recursion, Minimizing Mutable State and Reducing Side Effects

N

names of people, localizing, Localizing Your Code
namespaces
collection of functions under single namespace, Modular Code Organization
using to segment Rake tasks, Rake: Ruby’s Built-in Build Utility
Net::FTP module, Working with HTTP and FTP (open-uri)
new( ) method, object modification and, Per-Object Modification
:nodoc: directive, Controlling Output with RDoc Directives
nokogiri gem, Testing Complex Output
NoMethodError, Handling Messages with method_missing() and send()
nongreedy quantifiers, Use Caution When Working with Quantifiers
normalize_encoding methods, Transcoding User Input in an Organized Fashion

O

Object class, inclusion of modules at runtime, Detecting Newly Added Functionality
Object#inspect method, Utilizing Reflection
Object#to_proc, Higher-Order Procedures
object-relational mapping (ORM), ActiveRecord, Exclamation points
Object.method_added( ) function, Detecting Newly Added Functionality
objects, Mastering the Dynamic Toolkit
implementing per-object behavior, Implementing Per-Object Behavior–Implementing Per-Object Behavior
key concepts, Implementing Per-Object Behavior
modifying, Per-Object Modification
per-object customization not affecting class definition, Implementing Per-Object Behavior
Oniguruma, Oniguruma
open-uri standard library, Working with HTTP and FTP (open-uri)–Working with HTTP and FTP (open-uri)
using with json, Human-Readable Data Serialization (json)
OpenURI::HTTPError, Working with HTTP and FTP (open-uri)
OpenURI::Meta module, Working with HTTP and FTP (open-uri)
operators, custom, Make Use of Custom Operators
options hashes
forwarding, Designing for Convenience: Ruport’s Table() feature
mandatory arguments and, Pseudo-Keyword Arguments
ordinal arguments
with optional parameters, Ordinal Arguments with Optional Parameters
standard, Standard Ordinal Arguments

P

parameterized subclassing, Building Classes and Modules Programmatically
parsers, Use Caution When Working with Quantifiers
parser for Adobe Font Metrics file, Text Processing and File Management–Line-Based File Processing with State Tracking
RSS and XML, Testing Complex Output
parse_array method, Lexical Parsing with Regular Expressions (strscan)
parse_value method, Lexical Parsing with Regular Expressions (strscan)
parsing strings, numbers, and booleans, Lexical Parsing with Regular Expressions (strscan)
password storage, secure, Cryptographic Hash Functions (digest)
passwords, setting, Cryptographic Hash Functions (digest)
Pathname module, Using Pathname and FileUtils
Patterson, Aaron, Testing Complex Output
PDF documents, embedding images in, Cryptographic Hash Functions (digest)
PDF::Writer, managing memory consumption issue, Per-Object Modification
performance
recursion and, Minimizing Mutable State and Reducing Side Effects
text processing and file management, Conclusions
using Memoizable module versus manual caching, Memoization
pp (prettyprint) standard library, Improving inspect Output, Pretty-Printer for Ruby Objects (pp)–Pretty-Printer for Ruby Objects (pp)
prawn gem, dependencies, Working with Dependencies–Working with Dependencies
Prawn PDF generation library, Designing for Testability
inline styling support, Designing for Testability
prawn/compatibility.rb, Compatibility Shims for Common Operations
Prawn::Document#inspect output, Utilizing Reflection
Prawn::Document#render_file method, Working with Files
Prawn::Document, documentation, Basic Documentation Techniques and Guidelines
Prawn::Font#normalize_encoding method, Transcoding User Input in an Organized Fashion
Prawn::Font::TTF#normalize_encoding method, Transcoding User Input in an Organized Fashion
pre/postprocessing, using blocks to abstract, Using Blocks to Abstract Pre- and Postprocessing–Using Blocks to Abstract Pre- and Postprocessing
pretty-printer for Ruby objects (pp), Pretty-Printer for Ruby Objects (pp)–Pretty-Printer for Ruby Objects (pp)
PrettyPrint class, Pretty-Printer for Ruby Objects (pp)
pretty_print method, Pretty-Printer for Ruby Objects (pp)
pretty_print_inspect method, Pretty-Printer for Ruby Objects (pp)
Prime class, Mathematical Ruby Scripts (mathn)
Proc objects, Higher-Order Procedures
lazy evaluation, Laziness Can Be a Virtue (A Look at lazy.rb)
new syntax in Ruby 1.9, New Proc Syntax
Proc#arity method, Making instance_eval() Optional
procedures, higher-order, Higher-Order Procedures–Higher-Order Procedures
project maintenance, Skillful Project Maintenance–Conclusions
API documentation via RDoc, API Documentation via RDoc–Controlling Output with RDoc Directives
basic documentation guidelines, Basic Documentation Techniques and Guidelines–Basic Documentation Techniques and Guidelines
output control with RDoc directives, Controlling Output with RDoc Directives–Controlling Output with RDoc Directives
conventions to know about, Conventions to Know About–Examples
examples, Examples–Examples
executables, Executables
library layout, Laying Out Your Library–Laying Out Your Library
README file contents, What Goes in a README–What Goes in a README
summary of key points, Examples
tests, Tests
exploring well-organized project, Exploring a Well-Organized Ruby Project (Haml)–Exploring a Well-Organized Ruby Project (Haml)
Rake, Rake: Ruby’s Built-in Build Utility–Rake: Ruby’s Built-in Build Utility
RubyGems package manager, The RubyGems Package Manager–Working with Dependencies
dependencies, Working with Dependencies–Working with Dependencies
summary of key points, Working with Dependencies
writing gem specification, Writing a Gem::Specification–Writing a Gem::Specification
project management utilities in Ruby, Skillful Project Maintenance
Promise objects, Laziness Can Be a Virtue (A Look at lazy.rb)
promise( ) method, Laziness Can Be a Virtue (A Look at lazy.rb)
pseudo-keyword arguments, Ordinal Arguments with Optional Parameters
pseudo-keyword hash syntax, Pseudo-Keyword Hash Syntax
PStore objects, constructing and using, Transactional Filesystem-Based Data Storage (pstore)
pstore standard library, Transactional Filesystem-Based Data Storage (pstore)–Transactional Filesystem-Based Data Storage (pstore)
API documentation, Basic Documentation Techniques and Guidelines

Q

quantifiers in regular expressions, Use Caution When Working with Quantifiers

R

Rake, Skillful Project Maintenance, Rake: Ruby’s Built-in Build Utility–Rake: Ruby’s Built-in Build Utility
custom tasks, Rake: Ruby’s Built-in Build Utility
rake build command, Rake: Ruby’s Built-in Build Utility
rake rdoc task, Rake: Ruby’s Built-in Build Utility
Rakefiles, Rake: Ruby’s Built-in Build Utility
rubyforge command-line utility, Rake: Ruby’s Built-in Build Utility
summary of key points, Rake: Ruby’s Built-in Build Utility
uploading website documentation via scp, Rake: Ruby’s Built-in Build Utility
rake install task, Haml project, Exploring a Well-Organized Ruby Project (Haml)
rake task listing, Haml project, Exploring a Well-Organized Ruby Project (Haml)
rake test command, Exploring a Well-Organized Ruby Project (Haml)
using to automate running of test suite, Run the Whole Suite at Once
Rake::GemPackageTask, Exploring a Well-Organized Ruby Project (Haml)
Rational objects, Mathematical Ruby Scripts (mathn)
RDoc, Skillful Project Maintenance
API documentation via, API Documentation via RDoc–Controlling Output with RDoc Directives
basic documentation guidelines, Basic Documentation Techniques and Guidelines–Basic Documentation Techniques and Guidelines
controlling output with directives, Controlling Output with RDoc Directives–Controlling Output with RDoc Directives
generated from source, Exploring a Well-Organized Ruby Project (Haml)
generation of, details in gemspec, Writing a Gem::Specification
website, Controlling Output with RDoc Directives
README file
contents of, What Goes in a README–What Goes in a README
Haml project, Exploring a Well-Organized Ruby Project (Haml)
read_to_char, m17n-Safe Low-Level Text Processing
recursion
drawbacks in Ruby, Minimizing Mutable State and Reducing Side Effects
performance problems with, Minimizing Mutable State and Reducing Side Effects
reducing with memoization, Memoization
rewriting recursive solutions iteratively, Minimizing Mutable State and Reducing Side Effects
using Enumerable#inject instead of, Minimizing Mutable State and Reducing Side Effects
refactoring, Designing for Testability
using automated behavior verification, Designing for Testability
reflection, BlankSlate: A BasicObject on Steroids–BlankSlate: A BasicObject on Steroids
determining names of instance methods, BlankSlate: A BasicObject on Steroids
reflection, using to inspect code, Utilizing Reflection–Utilizing Reflection
Regexp.escape( ) method, m17n by Example: A Look at Ruby’s CSV Standard Library
regular expressions, Regular Expressions–Use Caution When Working with Quantifiers
anchors in, Anchors Are Your Friends
caution with quantifiers, Use Caution When Working with Quantifiers
defining to match text in encoding different from source, m17n by Example: A Look at Ruby’s CSV Standard Library
escaping special characters, m17n by Example: A Look at Ruby’s CSV Standard Library
guidelines for, Use Caution When Working with Quantifiers
lexical parsing with (strscan), Lexical Parsing with Regular Expressions (strscan)–Lexical Parsing with Regular Expressions (strscan)
Oniguruma engine, Oniguruma
special characters in pattern syntax, Regular Expressions
specifying character encoding for, Source Encodings
writing clean, tight patterns, Don’t Work Too Hard
reports, writing from CSV files, Working with Tabular Data (csv)
require statements for testing, Test Helpers
requires, Laying Out Your Library–Laying Out Your Library
deeply nested classes in projects, Laying Out Your Library
rescuing a failure and reraising an error, Finding Needles in a Haystack
resources (external), removing dependencies on, Using Mocks and Stubs
revision control system, git, Cryptographic Hash Functions (digest)
RSpec code, Building Flexible Interfaces
RSS feed, testing, Testing Complex Output–Testing Complex Output
Ruby Quiz website, Lexical Parsing with Regular Expressions (strscan)
Ruby worst practices, Ruby Worst Practices–Conclusions
downside of cleverness, The Downside of Cleverness
evils of eval( ), The Evils of eval()–The Evils of eval()
method_missing, Doing method_missing Wrong–Doing method_missing Wrong
rescuing exceptions, Blind Rescue Missions–Blind Rescue Missions
unintelligent design, Not-So-Intelligent Design
class variables, Class Variables Considered Harmful–Class Variables Considered Harmful
hardcoding class names, Hardcoding Yourself Into a Corner–Hardcoding Yourself Into a Corner
inheritance becoming restrictive, When Inheritance Becomes Restrictive–When Inheritance Becomes Restrictive
RubyGems, Modification via Aliasing, Skillful Project Maintenance
package manager, The RubyGems Package Manager–Working with Dependencies
dependencies, Working with Dependencies–Working with Dependencies
summary of key points, Working with Dependencies
writing Gem::Specification, Writing a Gem::Specification–Writing a Gem::Specification
runtime dependencies, Working with Dependencies
Ruport
abstract formatting system (Fatty), Ruport 2.0, Building Classes and Modules Programmatically
managing memory consumption issue in PDF::Writer, Per-Object Modification
Table( ) feature, Designing for Convenience: Ruport’s Table() feature–Designing for Convenience: Ruport’s Table() feature
Ruport::Data::Table.load( ), Designing for Convenience: Ruport’s Table() feature
Ruport::Data::Table.new( ), Designing for Convenience: Ruport’s Table() feature

S

safe_level, Embedded Ruby for Code Generation (erb)
salt, adding to password hash, Cryptographic Hash Functions (digest)
Sass, Tests
saves, atomic, Atomic Saves
Scheduler class, implementing, Working with Dates and Times (date)
scrutinizing code, Scrutinizing Your Code–Finding Needles in a Haystack
finding defects in very large dataset, Finding Needles in a Haystack
guidelines for, Finding Needles in a Haystack
improving inspect output, Improving inspect Output
using reflection, Utilizing Reflection–Utilizing Reflection
search results, from Google web search, Human-Readable Data Serialization (json)
:section: directive, rdoc, Controlling Output with RDoc Directives
secure password storage, Cryptographic Hash Functions (digest)
send( ) method, using with method_missing( ), Handling Messages with method_missing() and send()
serialization
human-readable (json), Human-Readable Data Serialization (json)–Human-Readable Data Serialization (json)
yaml standard library, Improving inspect Output–Improving inspect Output
SHA256 hashes, Cryptographic Hash Functions (digest)
shortcuts in regular expressions, Don’t Work Too Hard
side effects
avoiding in testing, Well-Focused Examples
reducing in Ruby code, Minimizing Mutable State and Reducing Side Effects–Minimizing Mutable State and Reducing Side Effects
Sinatra application for Rock, Paper, Scissors game, Localizing Your Code
singleton class, Implementing Per-Object Behavior
sjis_re function, m17n by Example: A Look at Ruby’s CSV Standard Library, m17n by Example: A Look at Ruby’s CSV Standard Library
sockets, network I/O via, Using Blocks to Abstract Pre- and Postprocessing–Using Blocks to Abstract Pre- and Postprocessing
something( ) and something=( ) methods, Use attr_reader, attr_writer, and attr_accessor
SortedList, adding reporting method to, Working with Enumerable
source encodings, setting, Source Encodings
spaceship operator (<=>), Make Use of Custom Operators
spec.test_files, Writing a Gem::Specification
StandardError class, Working with Logger
StandardError#report method, Working with Logger
state
minimizing mutable state and reducing side effects, Minimizing Mutable State and Reducing Side Effects–Minimizing Mutable State and Reducing Side Effects
tracking in line-by-line text processing, Line-Based File Processing with State Tracking–Line-Based File Processing with State Tracking
string interpolation versus ERB, Embedded Ruby for Code Generation (erb)
String iterators, String Iterators
string literals, specifying character encoding for, Source Encodings
String#ascii_only? method, Transcoding User Input in an Organized Fashion
String#encode method, m17n-Safe Low-Level Text Processing
String#encode! method, Transcoding User Input in an Organized Fashion
String#ord method, m17n-Safe Low-Level Text Processing
String#unpack method, m17n-Safe Low-Level Text Processing
String#valid_encoding? method, m17n-Safe Low-Level Text Processing
StringIO class, Using Mocks and Stubs
StringIO objects, returned by open-uri, Working with HTTP and FTP (open-uri)
strings
character-awareness, Character Operations
lexical parsing with regular expressions (strscan), Lexical Parsing with Regular Expressions (strscan)–Lexical Parsing with Regular Expressions (strscan)
StringScanner class, Lexical Parsing with Regular Expressions (strscan)
StringScanner#matched method, Lexical Parsing with Regular Expressions (strscan)
strscan standard library, Lexical Parsing with Regular Expressions (strscan)–Lexical Parsing with Regular Expressions (strscan)
stubbing system, building for testing, Implementing Per-Object Behavior–Implementing Per-Object Behavior
stubs
third party tools for, Using Mocks and Stubs
uses of, Testing Complex Output
using in testing, Using Mocks and Stubs
subclasses, detecting and tracking inheritance, Tracking Inheritance
subclassing, parameterized, Building Classes and Modules Programmatically
super( ) method, Per-Object Modification
using with method_missing, Handling Messages with method_missing() and send()
Symbol#to_proc, Higher-Order Procedures

T

Table( ) method (Ruport), Designing for Convenience: Ruport’s Table() feature–Designing for Convenience: Ruport’s Table() feature
tabular data, working with (csv), Working with Tabular Data (csv)–Working with Tabular Data (csv)
TDD (test-driven development), Driving Code Through Tests, Testing Fundamentals
(see also testing)
problem discovery, refactoring, and iterative design, Designing for Testability
tempfile standard library, The tempfile Standard Library–Automatic Unlinking
automatic file unlinking, Automatic Unlinking
automatic handling of temporary directory, Automatic Temporary Directory Handling
I/O operations, using File methods, Same Old I/O Operations
name collision avoidance, Collision Avoidance
using for atomic saves, Atomic Saves
templates, code blocks as, Ruby’s Other Secret Power: Code Blocks
test/test_helpers.rb file, creating, Test Helpers
test/unit library, A Quick Note on Testing Frameworks
TestCase class
Class#inherited hook, Tracking Inheritance
extending, Adding New Functionality
testing, Driving Code Through Tests–Conclusions
complex output, Testing Complex Output–Testing Complex Output
designing for testability, Designing for Testability
exceptions, Testing Exceptions
frameworks for, A Quick Note on Testing Frameworks
generating fake data for, Finding Needles in a Haystack
highlights of advanced testing techniques, Testing Complex Output
keeping things organized, Keeping Things Organized
building custom assertions, Custom Assertions
embedding tests in library files, Embedding Tests in Library Files
summary of practices, Custom Assertions
using test helpers, Test Helpers
key guidelines for testing fundamentals, Run the Whole Suite at Once
running entire suite at once, Run the Whole Suite at Once
simple stubbing system for, Implementing Per-Object Behavior–Implementing Per-Object Behavior
use in describing how code should be used, Exploring a Well-Organized Ruby Project (Haml)
using mocks and stubs, Using Mocks and Stubs–Using Mocks and Stubs
using well-focused examples, Well-Focused Examples
writing test case in debugging process, A Process for Debugging Ruby Code
tests, Tests
Haml project, Exploring a Well-Organized Ruby Project (Haml)
RubyGems gemspec, Writing a Gem::Specification
text processing, Text Processing and File Management–Use Caution When Working with Quantifiers, Line-Based File Processing with State Tracking
(see also file management)
line-based file processing with state tracking, Line-Based File Processing with State Tracking–Line-Based File Processing with State Tracking
guidelines for, Line-Based File Processing with State Tracking
line-by-line, advanced techniques, Advanced Line Processing–Tracking line numbers
guidelines for, Atomic Saves
tracking line numbers, Tracking line numbers
using Enumerator, Using Enumerator
low level, m17n-safe, m17n-Safe Low-Level Text Processing–m17n-Safe Low-Level Text Processing
using regular expressions, Regular Expressions–Use Caution When Working with Quantifiers
text( ) method, Transcoding User Input in an Organized Fashion
Time class, Working with Dates and Times (date)
to_proc methods, Higher-Order Procedures
transactional filesystem-based data storage, Transactional Filesystem-Based Data Storage (pstore)–Transactional Filesystem-Based Data Storage (pstore)
transaction_simple( ), hook in PDF::Writer, Per-Object Modification
transcoding
between character encodings, Encoding Conversions
criteria for what needs transcoding, Transcoding User Input in an Organized Fashion
user input, Transcoding User Input in an Organized Fashion
transforms, using lazy stream, Infinite Lists
translation files, using in localization, Localizing Your Code
trim_mode, Embedded Ruby for Code Generation (erb)
trim_space helper method, Lexical Parsing with Regular Expressions (strscan)

U

UnboundMethod objects, BlankSlate: A BasicObject on Steroids
undef_method( ), BlankSlate: A BasicObject on Steroids
Unicode, Reducing Cultural Barriers
unit testing (see testing; tests)
unit testing framework (minitest/unit), A Quick Note on Testing Frameworks
URL routing, controllers to handle, Building Classes and Modules Programmatically
user input, transcoding, Transcoding User Input in an Organized Fashion–Transcoding User Input in an Organized Fashion
UTF-8 character encoding, m17n by Example: A Look at Ruby’s CSV Standard Library
writing UTF-8-enabled Ruby library, Portable m17n Through UTF-8 Transcoding–Transcoding User Input in an Organized Fashion

V

valid_encoding? method, m17n-Safe Low-Level Text Processing
variables, block-local, Block-Local Variables
Vector class, Mathematical Ruby Scripts (mathn)
versioning
Ruby versions, Writing Backward-Compatible Code
specifying in dependencies, Working with Dependencies

W

Wanstrath, Chris, Localizing Your Code
Weirich, Jim, Using Mocks and Stubs, Testing Complex Output, Mastering the Dynamic Toolkit
worst practices (see Ruby worst practices)

X

XML
parsing in Ruby, Testing Complex Output
RSS feeds, Testing Complex Output
XML Builder, Testing Complex Output, BlankSlate: A BasicObject on Steroids

Y

yaml standard library, Improving inspect Output–Improving inspect Output
file with Chinese translation for RPS game, Localizing Your Code
file with French translation for RPS game, Localizing Your Code
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.116.80.34