liveBookmanning.com

What you will learn in The Well-Grounded Rubyist, Fourth Edition

by David A Black and Joseph Leo III

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• enumerable protocolAn enumerable object is a Ruby object whose elements or generated values can be traversed through an each method and processed with Enumerable methods.
• method lookupA method lookup path is the ordered sequence of singleton classes, classes, and modules Ruby searches when resolving a method for an object.
• blockA block is a fragment of Ruby code supplied with a method call that the method can execute.
• scopeScope is the lexical region of a Ruby program in which a variable or other name is visible and can be resolved.
• enumeratorAn enumerator is a Ruby object that represents and controls iteration over an enumerable source, optionally allowing iteration without supplying a block immediately.
• class methodA class method is a method callable directly on a Ruby class object, including methods defined on that object or inherited by its class.
• singleton classSingleton class notation is Ruby syntax using class << object to open the singleton class of a specified object for definitions.
• class objectA class object is the Ruby object that represents a class and can receive methods independently of its instances.
• instance variableAn instance variable is a Ruby variable identified by a single-at-sign prefix and associated with an individual object.
• assignmentAssignment is the Ruby language operation that binds or updates an identifier with a reference to an object.
• regular expressionRegexp is Ruby's built-in class for representing regular expressions and providing operations for constructing and manipulating them.
• classClass is Ruby's built-in class whose instances represent classes and whose behavior supports class-level operations and instantiation.
• selfself is Ruby's implicit reference to the object that is the current method-execution receiver.
• singleton methodA singleton method is a method defined on one particular Ruby object rather than generally on all instances of its class.
• spaceship operatorThe spaceship operator is Ruby's three-way comparison operator that returns an ordering result indicating whether its left operand is less than, equal to, or greater than its right operand.
• moduleA module is a Ruby construct that groups constants, methods, and other definitions under a namespace and can provide reusable behavior.
• MapA key-value data structure that associates keys with corresponding values and preserves the insertion order of its keys.
• method_missingmethod_missing is a Ruby method invoked as a last resort when an object receives a message for which no matching method is found.
• regex groupingA submatch is the substring matched by a parenthesized subpattern within a regular-expression match.
• instance_methodinstance_method is a Ruby class method that returns an unbound method object for an instance method.
• lambdaA lambda is a Ruby callable object representing an anonymous function with lambda-specific argument and return behavior.
• static fieldA class variable is a Ruby variable whose information is shared per class hierarchy and whose name begins with two at-signs.
• global variableA global variable is a Ruby variable identified by a leading dollar sign and accessible globally according to Ruby's variable semantics.
• callbackA callback is a method or function that a runtime invokes automatically in response to a specified event or lifecycle operation.
• each_entryThe Ruby each method invokes a block once for every element in a collection or once for every value produced by an enumerator.
• conditional logicif is a Ruby conditional construct that executes code when a condition is truthy and can provide alternative branches.
• match methodA match is an operation that tests whether text satisfies a regular expression and may return information about the match.
• inputA parameter is a named input in a method definition or block that receives a corresponding argument when the callable is invoked.
• file objectA file handle is a program-accessible object or reference representing an open file and its associated input or output stream.
• bang methodBang notation is the exclamation-mark suffix convention in Ruby method names that signals potentially unexpected or otherwise divergent behavior.
• symbolSymbol is Ruby's built-in class whose instances are immutable symbol values representing distinct names or identifiers.
• accessor methodAn attribute accessor method is a method that provides access to an object's attribute by reading or writing its value.
• exceptionAn exception is a Ruby runtime event representing an abnormal condition that interrupts ordinary program execution and can be handled by exception mechanisms.
• super keywordsuper is a Ruby keyword that invokes the next implementation of the current method in the method-lookup path, preserving the current call's arguments and block when no argument syntax is supplied.
• bindingA variable is a Ruby identifier that refers to changeable stored information.
• constantA constant is a Ruby identifier whose name begins with an uppercase letter and conventionally denotes a value intended not to be reassigned.
• pass-through changeA pass-through override is a method override that performs additional behavior and then invokes the original method, typically forwarding its arguments and relying on its return value.
• aliasalias is a Ruby language construct that gives a method or other name an additional name without changing its behavior or method lookup.
• inheritanceClass inheritance is the Ruby mechanism by which a class derives behavior and structure from another class.
• ComparableComparable is a Ruby module that provides comparison-based methods to classes whose objects define a comparison operation.
• additive changeAn additive change is a modification that extends an existing Ruby class or module by adding functionality without replacing existing methods.
• method chainingA method chain is a sequence in which the result of one method call becomes the receiver of a subsequent method call.
• mixinA mixin is a module incorporated into a class or another module so that its methods participate in method lookup.
• superclassA superclass is the class from which another Ruby class inherits methods and other behavior.
• missing valuenil is Ruby’s singleton object representing the absence of a meaningful value.
• objectInstantiation is the process of creating an object as an instance of a class.
• MatchDataMatchData is a Ruby object containing the results, captured substrings, and locations associated with a regular-expression match.
• method callA method call is a Ruby expression that invokes a method on an object, optionally supplying arguments and a block.
• RubyRuby is a dynamically typed, object-oriented programming language with garbage collection and an emphasis on expressive syntax.
• map!map! is a mutating collection method that replaces each element with the value produced by applying a transformation block.
• default valueA default argument is a method parameter with a value assigned when the caller does not supply that argument.
• extendextend is a Ruby method that adds the instance methods of one or more modules to a particular object's singleton class.
• refinementrefine is a Ruby method that defines a refinement for a class within a block.
• optional function argumentAn optional parameter is a method parameter whose value can be omitted because a default value is specified.
• required argumentA required argument is a method input that must be supplied for a method call to be valid.
• select!select! is a mutating collection method that removes elements failing a block-based selection test from the receiver and returns the modified collection or nil when no change occurs.
• ruby interpreterThe Ruby interpreter is the executable program that reads Ruby source programs and executes them.
• quantifierA regular-expression quantifier is a syntax element that specifies how many consecutive times a preceding pattern element may match.
• gsub!gsub! globally replaces matching substrings in a string in place and returns the modified string or nil when no replacement occurs.
• expressionA Ruby expression is syntactic code that can be evaluated to produce a value, including code continued across multiple lines.
• yieldyield is a Ruby keyword that transfers execution to the block associated with the currently running method and then resumes the method afterward.
• irbAn interactive Ruby interpreter evaluates Ruby input entered incrementally in a session rather than processing a source file.
• class-hierarchy scopeClass-hierarchy scope is the Ruby visibility rule under which a class variable is shared by a class and its descendants and their instances.
• messageMessage sending is the process of requesting behavior from a Ruby object by sending it a message.
• dotted notationThe dot operator is Ruby syntax that sends the expression on its right as a message to the object on its left.
• rescue clauserescue is Ruby's exception-handling construct for intercepting specified exceptions raised during execution.
• booleanA truth value is the Boolean interpretation Ruby assigns to an object when it is used as a condition.
• case equality operatorThe Ruby case equality operator is the === method whose receiver tests whether its argument matches a when condition.
• rangeRange is Ruby's built-in object representing a sequence bounded by beginning and ending values, or by a beginning value alone for an endless range.
• return valueA return value is the value produced by evaluating a Ruby method call, implicitly taken from the method's last evaluated expression unless execution returns earlier.
• BasicObjectA basic object is an instance of BasicObject with only the minimal set of methods provided by that class.
• private memberA private instance method is an instance method whose invocation cannot use an explicit receiver other than self.
• keywordA Ruby keyword is a predefined reserved term associated with a specific programming construct or syntactic context, including the logical-negation keyword not.
• to_procSymbol#to_proc creates a Proc that sends the symbol as a method name to each object it receives.
• identifierA Ruby identifier is a lexical name used to refer to a program element such as a variable, method, constant, or class.
• loopA loop is a control-flow construct that repeatedly executes a segment of code according to an unconditional, conditional, or collection-based rule.
• constructor methodA Ruby constructor is the class method conventionally named new that creates and returns an instance of the class.
• pure functionA pure function is a computation that produces its result from its inputs without observable side effects or dependence on mutable external state.
• sliceArray#slice is a Ruby Array method that retrieves elements specified by an index, an index and length, or a range.
• referenceAn object reference is a value that identifies a Ruby object rather than containing an independent copy of that object.
• threadThread is Ruby's class for creating and controlling threads of execution.
• object-oriented programmingObject-oriented programming is a programming paradigm that organizes computation around objects that encapsulate data and perform actions in response to requests.
• requireRuby's Kernel method that loads a feature once and records it so subsequent calls with the same feature do not reload it.
• interpolationString interpolation is the Ruby language feature that evaluates embedded expressions and inserts their results into a string or regular expression.
• function argumentA Ruby argument is a value supplied to a method call and is distinct from a supplied block.
• to_ito_i is a Ruby conversion method that produces an integer representation of a value and can interpret a string in a specified numeric base.
• escape sequenceCharacter escaping is syntax that represents special characters or prevents characters from being interpreted as delimiters or interpolation markers.
• falsefalse is Ruby's singleton object representing a false Boolean value.
• syntactic sugarSyntactic sugar is a language feature that provides a more convenient or readable syntax for expressing an operation supported by the language's ordinary rules.
• receiverAn explicit receiver is the object written before the dot in a Ruby method call.
• side effectA side effect is an observable consequence of evaluating code beyond producing its direct return value, such as mutating state or raising an exception.
• case statementA Ruby case statement is a conditional expression that selects execution based on matching a value against alternatives.
• core classA core class is a fundamental class provided by the Ruby language implementation and available to programs by default.
• grepgrep is a Ruby Enumerable method that selects elements whose case-equality comparison with a supplied argument is true and can optionally transform the selected elements with a block.
• class_evalclass_eval is a Ruby method that evaluates a string or block in the context of a class or module; module_eval is its alias.
• stateState is the information and data associated with an object that represents its current properties or condition.
• assertionA zero-width assertion is a regular-expression condition that checks text or position without consuming any characters.
• destructive methodDestructive behavior is behavior that changes the state of the receiver object rather than producing an unchanged receiver.
• attributeA property is an attribute or quality associated with an entity or object.
• putsputs is a Ruby output method that writes objects to an IO stream and normally appends a newline after each line.
• name-value pairA key/value pair, or hash entry, consists of a key and its associated value stored in a hash.
• nonbang methodA nondestructive method is a method that leaves its receiver unchanged and returns a new object containing the result.
• to_sto_s is a Ruby conversion method that returns a string representation of its receiver.
• per-object changePer-object change is adding or altering behavior for one individual object without changing the behavior of other instances of its class.
• tap combinatortap yields its receiver to a supplied block and then returns that receiver unchanged as the method result.
• regular-expression anchorA regular-expression anchor is a zero-width pattern assertion that constrains a match to a structural position such as the start or end of text.
• sendsend is a Ruby method, also available as __send__, that invokes a named method on an object and can bypass method visibility restrictions.
• greedy matchingA greedy quantifier matches as many repetitions as possible while still allowing the remainder of the regular expression to match.
• IOAn I/O object is a Ruby object that represents an input or output stream and provides operations for transferring data.
• method objectA Method object is a Ruby object that encapsulates a method bound to a receiver and can be invoked as executable behavior.
• stack traceStack tracing is the technique of examining the sequence of active calls during program execution.
• callableA callable object is an object that provides a way to invoke encapsulated behavior as a function-like operation.
• methodsmethods is a Ruby method that returns an array containing the names of methods available to an object.
• method accessA method access level is a Ruby visibility classification that controls how a method may be called.
• higher-order functionA higher-order function is a function that takes another function as an argument or returns a function as its result.
• rejectreject is a Ruby Hash and Enumerable method that returns a new collection containing elements for which a supplied block returns a falsy value.
• Array#digHash#dig is a Ruby Hash method that traverses nested hashes using a sequence of keys and returns the value at the resulting path.
• force_encodingforce_encoding is a Ruby String method that assigns an encoding to a string's existing bytes without validating or converting those bytes.
• functional, stateless philosophyA functional language is a programming language that emphasizes computation through functions and minimizes mutable state and side effects.
• collectionA collection is an object that groups multiple elements and supports operations for examining or traversing those elements.
• character encodingAn encoding is a scheme that maps sequences of bytes to textual characters and determines their representation.
• Dir.globDir.[] is Ruby's index-style directory globbing method for returning pathnames matching a glob pattern.
• floating-point arithmeticFloat is Ruby's built-in class for representing finite-precision floating-point numeric values.
• object individuationObject individuation is the practice of giving selected Ruby objects additional methods or capabilities tailored to their runtime circumstances.
• substringA substring is a contiguous sequence of characters extracted from a string or string-like value.
• all_with_* method patternThe all_with_* method pattern is a naming scheme in which a method prefix identifies an attribute whose matching objects should be searched.
• block parameterA block parameter is a formal input listed between pipes in a Ruby block and bound to a value when the block is invoked.
• findfind, also known as detect, is an Enumerable method that returns the first element for which its block evaluates truthily, or nil when no element matches.
• when clauseA when clause is a branch of a Ruby case statement containing match conditions and code to execute when a condition matches.
• each_byteeach_byte is a Ruby String method that iterates over a string's bytes and can return an enumerator when no block is supplied.
• immutable collectionImmutability is the property of data or objects that prevents their state from being changed after creation.
• assert_equalassert_equal is a Minitest assertion method that compares an expected value with an actual value using Ruby equality.
• string literalA string literal is Ruby source syntax that directly represents a String value.
• dateDate is a Ruby class provided by the date library for representing and manipulating calendar dates.
• timestampDateTime is a Ruby class provided by the date library for representing calendar dates together with times and related calendar information.
• setA set is a collection data structure that stores distinct values without representing them as an indexed sequence.
• shiftArray#shift is a Ruby Array method that removes and returns the first element or a specified number of elements from an array.
• bytesA byte is a unit of digital data consisting of eight bits and serving as a basic unit of file storage and input.
• [][] is a Ruby String method that retrieves characters or substrings using indexes, ranges, strings, or regular expressions.
• referential transparencyReferential transparency is the property that an expression can be replaced by its resulting value without changing program behavior.
• cyclecycle is a Ruby Enumerable method that repeatedly traverses an enumerable object's elements, optionally for a specified number of cycles.
• array literalAn array literal is Ruby syntax that constructs an array using square brackets and optional element expressions.
• array methodThe Array method is a Ruby top-level conversion method that returns an array representation of its argument.
• %i array constructorThe %i array constructor is Ruby syntax that creates an array of symbols from whitespace-separated content, with %I enabling double-quoted interpolation rules.
• try_convert methodA try_convert method is a Ruby class method that conditionally invokes a compatible conversion method on an argument and returns nil when that method is unavailable.
• %w array constructorThe %w array constructor is Ruby syntax that creates an array of strings from whitespace-separated content, with %W enabling double-quoted interpolation rules.
• hash keyAn object used to retrieve a corresponding value from a hash.
• ampersand prefix operatorThe ampersand operator is Ruby syntax that converts a block or callable object for use as a method call's block argument.
• methodA method definition is Ruby source code that declares the name, parameters, and executable behavior of a method.
• StringIOStringIO is a Ruby standard-library class that provides an IO-like interface over a string held in memory.
• system programAn external program is a separately executed operating-system process that another program can communicate with.
• sort!sort! is a Ruby Array method that sorts the receiver in place.
• method_addedmethod_added is a Ruby callback method invoked when an instance method is defined or redefined in a class or module.
• splat operatorThe splat operator is Ruby's * syntax for expanding an array or array-convertible object into a list of elements or arguments.
• TimeTime is Ruby's built-in class for representing, manipulating, and formatting times and dates.
• to_ato_a is a Ruby conversion method that produces an array representation of an object.
• top-level methodA top-level method is a Ruby method available from the top-level execution context, typically through private methods supplied by Kernel.
• getsgets is a Ruby input method that reads the next line from a file or other input stream and returns nil at end of input.
• reflectionIntrospection, also called reflection, is the examination of a program's objects, methods, or state while the program is running.
• double-quoted stringA double-quoted string is a Ruby string literal delimited by double quotation marks that supports interpolation and escape processing.
• heredoc templateA heredoc is Ruby syntax for creating a string from source text extending to a designated terminating delimiter.
• percent-style string notationPercent-style string notation is Ruby syntax beginning with a percent sign that creates a string using a selectable delimiter and single- or double-quoted semantics.
• delimiterA delimiter is a character or string marking the boundary of a literal or heredoc body in Ruby source code.
• single-quoted stringA single-quoted string is a Ruby string literal delimited by single quotation marks with restricted interpolation and escape processing.
• squiggly heredocA squiggly heredoc is a Ruby heredoc form that removes leading indentation from its content.
• to_aryto_ary is Ruby's implicit array-conversion method for providing an Array-compatible representation when an actual array is required.
• default receiverA default receiver is the implicit object to which a Ruby method call is sent when no receiver is written.
• type signatureA method signature specifies the valid calling form of a method, including its parameters.
• to_symto_sym is a Ruby conversion method that returns a symbol corresponding to a value's textual representation.
• Hash.newThe Ruby Hash class method that creates a hash, optionally assigning a default value for nonexistent keys.
• character classThe word character class is the regular-expression character class matching letters, numbers, and underscore.
• command-line argumentA command-line option that instructs the Ruby interpreter to perform an action or change its behavior.
• deletedelete is a Ruby String method that returns a string with characters matching specified character-set arguments removed.
• closureA closure is executable code together with the lexical variables captured from the environment in which it was created.
• standard libraryThe standard library is the collection of libraries distributed with Ruby to provide commonly needed programming functionality.
• MatchData#capturesMatchData#captures returns an array of the substrings captured by the regular expression's parenthesized capture groups.
• reduction operationinject, also known as reduce, is an Enumerable method that combines collection elements through an accumulator and a block, optionally starting with an initial value.
• standard inputStandard input is a process's conventional input stream for receiving data from its environment.
• literal constructorA literal constructor is syntax that creates a value or object directly without an explicit call to a class constructor method such as new.
• loadA Ruby method that locates and evaluates a source file each time it is invoked, using the load path unless given an explicit path.
• regular expression flagA regexp modifier is a letter appended to a Ruby regular-expression literal that changes how matching or parsing behaves.
• private_instance_methodsprivate_instance_methods is a Ruby Module method that returns the private instance methods available from a class or module, optionally including inherited and included methods.
• RubyGemsA Ruby gem is a packaged Ruby library or application distributed as a file with a .gem extension.
• standard outputThe standard output stream is the default character stream through which a process writes ordinary textual output.
• includeModule inclusion is the Ruby mechanism that adds a module's instance methods to a class's method lookup chain.
• conditional modifierA conditional modifier is postfix Ruby syntax that conditionally executes a statement without enclosing it in a compound conditional block.
• else clauseThe else keyword introduces the alternative branch of a conditional statement when preceding conditions do not succeed.
• elsif keywordThe elsif keyword introduces an additional condition and branch in a Ruby conditional statement.
• unless expressionThe unless keyword introduces a conditional construct whose body executes when its condition is false.
• conditional matchA conditional match selects between regular-expression subexpressions according to whether a specified capture was found.
• lookaheadA lookahead assertion checks whether a specified subexpression follows the current position without consuming the checked characters.
• lookbehind assertionA lookbehind assertion is a regular-expression assertion that checks text immediately preceding the current match position without consuming that text.
• noncapturing groupA non-capturing group groups a regular-expression subexpression for matching without storing its text as a numbered capture.
• word boundaryA word boundary anchor constrains a match to a transition between word and non-word characters or to a string boundary.
• inheritedinherited is a Ruby class method callback invoked on a class when that class is subclassed, receiving the new subclass as its argument.
• test setupA setup method is a test-support method that prepares the state required before a test method runs.
• testA test method is a method whose name begins with test and that contains executable assertions for a test case.
• non-greedy quantifierA non-greedy quantifier matches the fewest repetitions needed for the remainder of the regular expression to match.
• block-local variableA block-local variable is a variable declared after the semicolon in a block parameter list and kept distinct from same-named variables outside the block.
• itit is Ruby's implicit block parameter that supplies the block's single automatic value without pipe-style parameter syntax.
• thread keyA thread key is a symbol or string used to associate a value with a thread's built-in key-value storage.
• string conversionString conversion is the derivation of a string or another object representing a string value in a different form.
• Array#values_atHash#values_at is a Ruby Hash method that retrieves the values associated with multiple specified keys and returns them in an array.
• StandardErrorStandardError is Ruby's class for the standard group of application-level exceptions that commonly inherit from it.
• first elementfirst is an Enumerable method that returns the first element or a specified number of initial elements from an enumerable object.
• caller_locationscaller_locations is a Ruby Kernel method that returns structured locations for the current call stack instead of formatted location strings.
• iteratorAn iterator is a method or construct that automatically traverses the elements of a collection.
• KernelKernel is Ruby's built-in module containing fundamental methods that are available to Object instances through inclusion in Object.
• sort_bysort_by is a Ruby Enumerable method that orders collection elements by comparing keys computed from each element by a block.
• comparisonA comparison operator is Ruby syntax that compares two values or objects for ordering or equality.
• rakeRake is a Ruby-based build utility that defines and runs task-based automation scripts.
• arityArity is the number of arguments that a callable Ruby object or method accepts according to its argument rules.
• regular expression literalA regexp literal is Ruby syntax that directly represents a regular expression between delimiters, optionally followed by modifiers.
• with_indexeach_with_index is an Enumerable method that invokes a block for each element while supplying the element's ordinal index.
• same-named methodA same-named method is one of multiple methods sharing a name across the classes and modules in an object's method lookup path.
• taketake is an Enumerable method that returns a specified number of elements from the beginning of an enumerable.
• popArray#pop is a Ruby Array method that removes and returns one or more objects from the end of an array.
• Array#unshiftArray#unshift is a Ruby Array method that adds one or more objects to the beginning of an array.
• pushArray#push is a Ruby Array method that appends one or more objects to the end of an array.
• rescue blockA begin/rescue clause is Ruby exception-handling syntax that executes rescue code when a matching exception is raised.
• lazy enumeratorA lazy enumerator is a Ruby enumerator that defers producing elements until results are requested.
• evaleval is a Ruby method that parses and executes Ruby code supplied as a string within a specified execution context.
• instance_methodsinstance_methods is a Ruby Module method that returns the public and protected instance methods available from a class or module, optionally including inherited and included methods.
• lazy evaluationLazy evaluation defers producing results until they are requested rather than materializing all results in advance.
• alias_methodalias_method is a private Module instance method that assigns an additional method name to an existing method using a symbol or string identifier.
• additive/pass-through hybridAn additive/pass-through hybrid is an override that preserves the original method behavior while adding functionality or interface options.
• method collisionA method collision is an unintended conflict caused when multiple libraries define or override the same method with incompatible behavior or interfaces.
• chompchomp is a Ruby String method that removes a specified record separator from the end of a string when present, defaulting to a newline.
• public methodA non-private method is a Ruby method that can be invoked through ordinary method-call syntax with an explicit receiver.
• bundlingBundler is a Ruby dependency manager that resolves and installs the exact gem versions specified for a project.
• continuous improvementIteration is a technique in which a method call is supplemented with code that the method can invoke during its execution.
• pattern matchingPattern matching is a technique for selecting behavior by testing the structural shape and contents of a value against declarative patterns.
• Ruby parserThe Ruby parser is the component that analyzes Ruby source code and determines its syntactic structure and variable classifications.
• functionA function is a callable computation that can be passed as a value or returned as a value in a functional programming style.
• distinct valueuniq is a Ruby Array method that returns a new array with duplicate elements removed according to equality comparison.
• dotThe dot wildcard character is the regular-expression metacharacter that normally matches any character except a newline.
• system methodThe system method is a Ruby method that executes an external command through the host operating system and reports whether it succeeded.
• operator precedencePrecedence is the rule governing how Ruby groups syntactic constructs when multiple constructs could be associated with an expression or method call.
• LIFO semanticsThe LIFO principle specifies that the last item entering a collection is the first item leaving it.
• or-equals operatorThe or-equals operator assigns its right-hand value only when its left-hand variable is nil or false.
• shortcut operatorA shortcut operator is Ruby syntax that combines an operation with assignment and expands to a call to an underlying method.
• stacklikenessStacklikeness is the property of allowing items to be added at one end and removing the most recently added item first.
• curryingCurrying is a functional programming technique that transforms a function of multiple arguments into a sequence of functions that can be evaluated incrementally.
• integer conversionInteger conversion transforms input data into an integer value suitable for numeric computation.
• PathnamePathname is a Ruby standard library class that represents filesystem pathnames and provides operations for querying and manipulating paths.
• indexingAn index is a numeric or key-based identifier for an element in a collection, including an ordinal position in an ordered collection.
• argument listAn argument list is the ordered collection of values supplied to a method call and interpreted according to the method's parameters.
• respond_to?respond_to? is a Ruby method that determines whether an object has a method capable of handling a specified message.
• TCPServerTCPServer is a Ruby socket class that listens for TCP connections and creates server-side connection sockets.
• parenthesisParentheses are Ruby syntax used to delimit the arguments of a method call and resolve syntactic ambiguity.
• top-levelTop-level scope is the lexical execution context of Ruby code written outside a class or module definition.
• private setter methodA private setter method is a Ruby setter method whose invocation is subject to private-method receiver restrictions, with self permitted as its explicit receiver.
• logical XORBitwise XOR is a binary operation that produces 1 where exactly one corresponding input bit is 1 and produces 0 where both corresponding input bits are equal.
• packpack is a Ruby Array method that converts array elements into a string according to a format directive.
• mergemerge is a Ruby Hash method that returns a new hash containing the receiver's pairs and another hash's pairs, with the other hash's values taking precedence for duplicate keys.
• size methodThe size method returns the number of elements in a Ruby collection.
• protected_instance_methodsprotected_instance_methods is a Ruby Module method that returns the protected instance methods available from a class or module, optionally including inherited and included methods.
• public_instance_methodspublic_instance_methods is a Ruby Module method that returns the public instance methods available from a class or module, optionally including inherited and included methods.
• respond_to_missing?respond_to_missing? is a Ruby callback method that lets an object report whether it can respond to a method handled dynamically by method_missing.
• Array.join()join is a Ruby Array method that returns a string formed by concatenating the string representations of the array's elements with an optional separator.
• Dir#entriesDir#entries is a Ruby method that returns the entries of a directory as an array.
• directory entryA directory entry is an item listed within a directory, such as a file, link, or subdirectory.
• hidden fileA hidden file is a filesystem file whose name is conventionally excluded from ordinary directory listings, commonly because it begins with a period.
• regular fileA regular file is a filesystem entity that stores ordinary file data rather than representing a directory, device, socket, or other special type.
• method nameA method name is the identifier by which a Ruby method is referred to, generally following local-variable naming rules with optional ?, !, or = suffixes.
• filteringFiltering is the technique of selecting elements from a collection that satisfy specified criteria.
• accumulatorAn accumulator is a value carried across iterations and replaced by each iteration's calculated result.
• built-in global variableA built-in global variable is a Ruby global variable initialized by the interpreter when Ruby starts.
• plus operatorThe Array#+ method is a Ruby method that returns a new array containing the elements of its operand arrays without mutating the receiver.
• instance_evalinstance_eval is a Ruby method that evaluates code in the context of a specified object, temporarily changing self to that object.
• Thread#fetchThread#fetch is a Ruby method that retrieves a value from a thread by key, optionally returning a supplied default when the key is absent.
• regex engineA regular-expression engine is software that interprets regular-expression patterns and searches input for matches.
• regular expression atomA regular expression atom is a single repeatable unit of a regular-expression pattern, such as a character, character class, or parenthesized subpattern.
• bareword invocationBareword style is invoking a Ruby method without writing an explicit receiver.
• last expressionThe last expression is the final expression evaluated in a Ruby method body, whose value becomes the method's implicit return value unless an explicit return intervenes.
• block-to-proc conversionA block-to-proc conversion is the conversion of a Ruby code block into a Proc object.
• Open3.popen3Open3.popen3 is a Ruby method that starts an external program and returns separate handles for its standard input, standard output, and standard error.
• is_a?is_a? is a Ruby method that tests whether an object is an instance of a specified class or one of its subclasses.
• method pairA method pair is a pair of similarly named Ruby methods in which the bang and nonbang forms perform substantially the same operation but differ in side effects, return value, or other behavior.
• integerInteger is Ruby's built-in class for representing whole-number values.
• POSIX character classPOSIX bracket notation is a standardized regular-expression syntax for specifying character classes using bracket expressions.
• backticksBackticks are Ruby syntax for executing an external command and returning its standard output as a string.
• Class.newClass.new is a Ruby class method that creates a class object, optionally with a specified superclass and block-defined contents.
• enum_forenum_for, also known as to_enum, is a Ruby method that creates an Enumerator attached to a specified method of an object, optionally supplying arguments to that method.
• until loopThe until keyword is a Ruby control-flow keyword that repeatedly executes a loop body until a condition becomes true.
• double-colon constant lookup tokenConstant lookup notation is Ruby syntax using a double colon to access a constant in a class or module.
• FileUtilsFileUtils is a Ruby standard library module providing high-level operations for manipulating files and directories.
• modularityModularization is the organization of software functionality into separate reusable modules.
• readlinereadline is a Ruby IO method that reads the next line from an input stream and raises an end-of-file error when no line is available.
• recursionRecursion is a programming technique in which a routine invokes itself, directly or indirectly, to solve a problem through progressively smaller or simpler subproblems.
• capitalizecapitalize is a Ruby String method that returns a string with its first character capitalized and the remaining characters lowercased.
• case conversionA case-changing method is a string or symbol operation that produces text with altered letter case.
• chopchop is a Ruby String method that returns a string with one character removed from its end.
• string incrementationString incrementation is the operation of producing the next string in Ruby's alphanumeric successor ordering.
• succsucc is a Ruby String method that returns the next string according to Ruby's alphanumeric successor rules.
• namespaceA Ruby namespace is a naming context that groups definitions and keeps names from different contexts distinct.
• $stderr$stderr is Ruby's reassignable global variable that refers to the current standard error stream.
• partial applicationPartial function application is a functional programming technique that applies fewer arguments than a function's arity and returns a function accepting the remaining arguments.
• singleton_methodssingleton_methods is a Ruby method that returns the public and protected singleton method names available to an object, excluding private singleton methods.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.