Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Programming
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Databases
Mail Systems
openSolaris
Eclipse Documentation
Techotopia.com
Virtuatopia.com

How To Guides
Virtualization
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Windows
Problem Solutions

  




 

 

Ruby Programming
Home Next Page

Ruby Programming

Table of Contents

Foreword

Preface

  • Ruby Sparkles
  • What Kind of Language Is Ruby?
  • Is Ruby for Me?
  • Why Did We Write This Book?
  • Ruby Versions
  • Installing Ruby
  • Building Ruby
  • Running Ruby
  • Interactive Ruby
  • Ruby Programs
  • Resources
  • Acknowledgments
  • Notation Conventions
  • Roadmap

    Ruby.new

  • Ruby Is an Object-Oriented Language
  • Some Basic Ruby
  • Arrays and Hashes
  • Control Structures
  • Regular Expressions
  • Blocks and Iterators
  • Reading and 'Riting
  • Onward and Upward
  • Classes, Objects, and Variables

  • Inheritance and Messages
  • Inheritance and Mixins
  • Objects and Attributes
  • Writable Attributes
  • Virtual Attributes
  • Class Variables and Class Methods
  • Class Variables
  • Class Methods
  • Singletons and Other Constructors
  • Access Control
  • Specifying Access Control
  • Variables
  • Containers, Blocks, and Iterators

  • Containers
  • Arrays
  • Hashes
  • Implementing a SongList Container
  • Blocks and Iterators
  • Implementing Iterators
  • Ruby Compared with C++ and Java
  • Blocks for Transactions
  • Blocks Can Be Closures
  • Standard Types

  • Numbers
  • Strings
  • Working with Strings
  • Ranges
  • Ranges as Sequences
  • Ranges as Conditions
  • Ranges as Intervals
  • Regular Expressions
  • Patterns
  • Anchors
  • Character Classes
  • Repetition
  • Alternation
  • Grouping
  • Pattern-Based Substitution
  • Backslash Sequences in the Substitution
  • Object-Oriented Regular Expressions
  • More About Methods

  • Defining a Method
  • Variable-Length Argument Lists
  • Methods and Blocks
  • Calling a Method
  • Expanding Arrays in Method Calls
  • Making Blocks More Dynamic
  • Collecting Hash Arguments
  • Expressions

  • Operator Expressions
  • Miscellaneous Expressions
  • Command Expansion
  • Backquotes Are Soft
  • Assignment
  • Parallel Assignment
  • Nested Assignments
  • Other Forms of Assignment
  • Conditional Execution
  • Boolean Expressions
  • Defined?, And, Or, and Not
  • If and Unless Expressions
  • If and Unless Modifiers
  • Case Expressions
  • Loops
  • Iterators
  • For ... In
  • Break, Redo, and Next
  • Retry
  • Variable Scope and Loops
  • Exceptions, Catch, and Throw

  • The Exception Class
  • Handling Exceptions
  • Tidying Up
  • Play It Again
  • Raising Exceptions
  • Adding Information to Exceptions
  • Catch and Throw
  • Modules

  • Namespaces
  • Mixins
  • Instance Variables in Mixins
  • Iterators and the Enumerable Module
  • Including Other Files
  • Basic Input and Output

  • What Is an IO Object?
  • Opening and Closing Files
  • Reading and Writing Files
  • Iterators for Reading
  • Writing to Files
  • But I Miss My C++ Iostream
  • Talking to Networks
  • Threads and Processes

  • Multithreading
  • Creating Ruby Threads
  • Manipulating Threads
  • Thread Variables
  • Threads and Exceptions
  • Controlling the Thread Scheduler
  • Mutual Exclusion
  • The Mutex Class
  • Condition Variables
  • Running Multiple Processes
  • Spawning New Processes
  • Independent Children
  • Blocks and Subprocesses
  • When Trouble Strikes

  • Ruby Debugger
  • Interactive Ruby
  • Editor Support
  • But It Doesn't Work!
  • But It's Too Slow!
  • Create Locals Outside Blocks
  • Use the Profiler
  • Ruby and Its World

  • Command-Line Arguments
  • Command-Line Options
  • ARGV
  • Program Termination
  • Environment Variables
  • Writing to Environment Variables
  • Where Ruby Finds Its Modules
  • Build Environment
  • Ruby and the Web

  • Writing CGI Scripts
  • Using cgi.rb
  • Quoting
  • Forms
  • Creating Forms and HTML
  • Cookies
  • Sessions
  • Embedding Ruby in HTML
  • Using eruby
  • Installing eruby in Apache
  • Improving Performance
  • Ruby Tk

  • Simple Tk Application
  • Widgets
  • Setting Widget Options
  • Getting Widget Data
  • Setting/Getting Options Dynamically
  • Sample Application
  • Binding Events
  • Canvas
  • Scrolling
  • Just One More Thing
  • Translating from Perl/Tk Documentation
  • Object Creation
  • Options
  • Variable References
  • Ruby and Microsoft Windows

  • Ruby Ports
  • Running Ruby Under Windows
  • Win32API
  • Windows Automation
  • Getting and Setting Properties
  • Named Arguments
  • for each
  • An Example
  • Optimizing
  • Extending Ruby

  • Ruby Objects in C
  • VALUE as a Pointer
  • VALUE as an Immediate Object
  • Writing Ruby in C
  • Evaluating Ruby Expressions in C
  • Sharing Data Between Ruby and C
  • Directly Sharing Variables
  • Wrapping C Structures
  • An Example
  • Memory Allocation
  • Creating an Extension
  • Creating a Makefile with extconf.rb
  • Static Linking
  • Embedding a Ruby Interpreter
  • Bridging Ruby to Other Languages
  • Ruby C Language API
  • The Ruby Language

  • Source Layout
  • BEGIN and END Blocks
  • General Delimited Input
  • The Basic Types
  • Integer and Floating Point Numbers
  • Strings
  • Ranges
  • Arrays
  • Hashes
  • Requirements for a Hash Key
  • Symbols
  • Regular Expressions
  • Regular Expression Options
  • Regular Expression Patterns
  • Substitutions
  • Extensions
  • Names
  • Variable/Method Ambiguity
  • Variables and Constants
  • Scope of Constants and Variables
  • Classes and Objects

  • How Classes and Objects Interact
  • Your Basic, Everyday Object
  • Object-Specific Classes
  • Mixin Modules
  • Extending Objects
  • Class and Module Definitions
  • Class Names Are Constants
  • Top-Level Execution Environment
  • Inheritance and Visibility
  • Freezing Objects
  • Locking Ruby in the Safe

  • Safe Levels
  • Tainted Objects
  • Reflection, ObjectSpace, and Distributed Ruby

  • Looking at Objects
  • Looking Inside Objects
  • Looking at Classes
  • Looking Inside Classes
  • Calling Methods Dynamically
  • Performance Considerations
  • System Hooks
  • Runtime Callbacks
  • Tracing Your Program's Execution
  • How Did We Get Here?
  • Marshaling and Distributed Ruby
  • Custom Serialization Strategy
  • Distributed Ruby
  • Compile Time? Runtime? Anytime!
  • Built-in Classes and Methods

    Standard Library

    Object-Oriented Design Libraries

  • The Visitor Pattern
  • Network and Web Libraries

  • Socket-Level Access
  • Higher-Level Access
  • CGI Development
  • HTML Output Methods
  • Multipart Form Values
  • Microsoft Windows Support

    Embedded Documentation

  • Inline Formatting
  • Cross References
  • Method Names
  • Including Other Files
  • Using rdtool
  • Mandatory Disclaimer
  • Interactive Ruby Shell

  • Command Line
  • Initialization File
  • Commands
  • Configuring the Prompt
  • Restrictions
  • rtags, xmp, and the Frame Class
  • rtags
  • xmp
  • The Frame Class
  • Support

  • Web Sites
  • Download Sites
  • Usenet Newsgroup
  • Mailing Lists
  • Bug Reporting
  • Ruby Programming
    Home Next Page

     
     
      Published under the terms of the Open Publication License Design by Interspire