Ruby Best Practices by Brown, Gregory T. -- Read -- Imperial Library of Trantor

Index

Ruby Best Practices

SPECIAL OFFER: Upgrade this ebook with O’Reilly Foreword Preface

Audience About This Book Conventions Used in This Book Using Code Examples Safari® Books Online How to Contact Us Acknowledgments

1. Driving Code Through Tests

A Quick Note on Testing Frameworks Designing for Testability Testing Fundamentals

Well-Focused Examples Testing Exceptions Run the Whole Suite at Once

Advanced Testing Techniques

Using Mocks and Stubs Testing Complex Output

Keeping Things Organized

Embedding Tests in Library Files Test Helpers Custom Assertions

Conclusions

2. Designing Beautiful APIs

Designing for Convenience: Ruport’s Table() feature Ruby’s Secret Power: Flexible Argument Processing

Standard Ordinal Arguments Ordinal Arguments with Optional Parameters Pseudo-Keyword Arguments Treating Arguments As an Array

Ruby’s Other Secret Power: Code Blocks

Working with Enumerable Using Blocks to Abstract Pre- and Postprocessing Blocks As Dynamic Callbacks Blocks for Interface Simplification

Avoiding Surprises

Use attr_reader, attr_writer, and attr_accessor Understand What method? and method! Mean

Question marks Exclamation points

Make Use of Custom Operators

Conclusions

3. Mastering the Dynamic Toolkit

BlankSlate: A BasicObject on Steroids Building Flexible Interfaces

Making instance_eval() Optional Handling Messages with method_missing() and send() Dual-Purpose Accessors

Implementing Per-Object Behavior Extending and Modifying Preexisting Code

Adding New Functionality Modification via Aliasing Per-Object Modification

Building Classes and Modules Programmatically Registering Hooks and Callbacks

Detecting Newly Added Functionality Tracking Inheritance Tracking Mixins

Conclusions

4. Text Processing and File Management

Line-Based File Processing with State Tracking Regular Expressions

Don’t Work Too Hard Anchors Are Your Friends Use Caution When Working with Quantifiers

Working with Files

Using Pathname and FileUtils

The tempfile Standard Library

Automatic Temporary Directory Handling Collision Avoidance Same Old I/O Operations Automatic Unlinking

Text-Processing Strategies

Advanced Line Processing

Using Enumerator Tracking line numbers

Atomic Saves

Conclusions

5. Functional Programming Techniques

Laziness Can Be a Virtue (A Look at lazy.rb) Minimizing Mutable State and Reducing Side Effects Modular Code Organization Memoization Infinite Lists Higher-Order Procedures Conclusions

6. When Things Go Wrong

A Process for Debugging Ruby Code Capturing the Essence of a Defect Scrutinizing Your Code

Utilizing Reflection Improving inspect Output Finding Needles in a Haystack

Working with Logger Conclusions

7. Reducing Cultural Barriers

m17n by Example: A Look at Ruby’s CSV Standard Library Portable m17n Through UTF-8 Transcoding

Source Encodings Working with Files Transcoding User Input in an Organized Fashion

m17n in Standalone Scripts

Inferring Encodings from Locale Customizing Encoding Defaults

m17n-Safe Low-Level Text Processing Localizing Your Code Conclusions

8. Skillful Project Maintenance

Exploring a Well-Organized Ruby Project (Haml) Conventions to Know About

What Goes in a README Laying Out Your Library Executables Tests Examples

API Documentation via RDoc

Basic Documentation Techniques and Guidelines Controlling Output with RDoc Directives

The RubyGems Package Manager

Writing a Gem::Specification Working with Dependencies

Rake: Ruby’s Built-in Build Utility Conclusions

A. Writing Backward-Compatible Code

Avoiding a Mess

Selective Backporting Version-Specific Code Blocks Compatibility Shims for Common Operations

Nonportable Features in Ruby 1.9

Pseudo-Keyword Hash Syntax Multisplat Arguments Block-Local Variables Block Arguments New Proc Syntax Oniguruma Most m17n Functionality

Workarounds for Common Issues

Using Enumerator String Iterators Character Operations Encoding Conversions

Conclusions

B. Leveraging Ruby’s Standard Library

Why Do We Need a Standard Library? Pretty-Printer for Ruby Objects (pp) Working with HTTP and FTP (open-uri) Working with Dates and Times (date) Lexical Parsing with Regular Expressions (strscan) Cryptographic Hash Functions (digest) Mathematical Ruby Scripts (mathn) Working with Tabular Data (csv) Transactional Filesystem-Based Data Storage (pstore) Human-Readable Data Serialization (json) Embedded Ruby for Code Generation (erb) Conclusions

C. Ruby Worst Practices

Not-So-Intelligent Design

Class Variables Considered Harmful Hardcoding Yourself Into a Corner When Inheritance Becomes Restrictive

The Downside of Cleverness

The Evils of eval() Blind Rescue Missions Doing method_missing Wrong

Conclusions

Index About the Author Colophon SPECIAL OFFER: Upgrade this ebook with O’Reilly

← Prev
Back
Next →

← Prev
Back
Next →