rkoans 0.0.1 → 0.1.0

data/exercises/dynamic-methods/dynamic_methods.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# The example deliberately contrasts received arguments with values actually used.
+# The example deliberately uses for rather than a block iterator.
+# rubocop:disable Lint/UnusedMethodArgument, Style/For
+
+module Exercises
+  # Implement readers(names) to return a new class with one instance reader per name, using
+  # define_method and instance_variable_get.
+  class DynamicMethods
+    # Builds a class whose readers capture their own instance-variable names.
+    # @return [Class]
+    def self.readers(names)
+      Class.new do
+        for name in names
+          define_method(name) { instance_variable_get("@#{name}") }
+        end
+      end
+    end
+
+    # Evaluates a fixed literal expression with access to the local binding.
+    # @return [Integer]
+    def self.evaluate(factor) = factor * 3
+    # Reads the named instance variable from the supplied object.
+    # @return [Object]
+    def self.instance_value(object, name) = nil
+    # Returns the class object seen as self inside class_eval.
+    # @return [Class]
+    def self.class_value(klass) = nil
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument, Style/For

data/exercises/dynamic-methods/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+A for loop shares the captured name; each-created block scopes avoid that trap.
+
+eval can use an explicit binding; class_eval changes the evaluation context for class-related operations.

data/exercises/exception-flow/brief.md

@@ -0,0 +1,8 @@
+# Ensure the trail survives
+
+Implement `trace(fail:)`: append "work"; if fail, raise and rescue a StandardError and append "rescue"; otherwise append "else". In both cases append "ensure" in an ensure clause. Return the ordered trail. Implement `reraises` so a rescued ArgumentError is re-raised with its original message.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `exception_flow.rb` in this exercise's folder. Checks call
+`Exercises::ExceptionFlow` and its example classes.

data/exercises/exception-flow/exception_flow.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Exercises
+  # Implement trace(fail:): append "work"; if fail, raise and rescue a StandardError and append
+  # "rescue"; otherwise append "else".
+  class ExceptionFlow
+    # Implements trace.
+    def self.trace(fail:)
+      trail = ['work']
+      begin
+        raise StandardError, 'failure' if fail
+      rescue StandardError
+        trail << 'rescue'
+      else
+        trail << 'else'
+      end
+      trail
+    end
+
+    # Implements reraises.
+    def self.reraises
+      raise ArgumentError, 'original'
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/exercises/exception-flow/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+else executes only after a successful begin body; ensure executes regardless of a rescued error.
+
+Cleanup belongs in ensure; avoid returning from ensure because that can replace the intended result or error.

data/exercises/heredoc-layout/brief.md

@@ -0,0 +1,14 @@
+# Whitespace is data
+
+A heredoc makes a multiline string between a starting delimiter and its closing
+line. Fix `render(name)` to return exactly `"Hello Ada\n  Ruby\n"` for `"Ada"`.
+Other names must interpolate too. Remove common source indentation while keeping
+the two spaces before `Ruby` and the final newline.
+
+Then fix `literal` to return the literal characters `Hello #{name}` followed by
+a newline. It must preserve the marker instead of inserting a variable's value.
+Keep both heredoc examples so you can compare indentation and quoting.
+
+Compare `<<-TEXT` with `<<~TEXT`, and an unquoted delimiter with a single-quoted
+one. An indented closing delimiter and stripped content indentation are different
+features. Save to rerun the checks automatically.

data/exercises/heredoc-layout/heredoc_layout.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Exercises
+  # Produces multiline strings while preserving deliberate relative indentation.
+  class HeredocLayout
+    # Fix the delimiter so common indentation disappears but Ruby stays indented.
+    # @param name [String] name interpolated into the greeting
+    # @return [String]
+    def self.render(name)
+      <<-TEXT
+        Hello #{name}
+          Ruby
+      TEXT
+    end
+
+    # Quote the delimiter so the interpolation marker remains literal text.
+    # @return [String]
+    def self.literal
+      name = 'Ada'
+      <<~TEXT
+        Hello #{name}
+      TEXT
+    end
+  end
+end

data/exercises/heredoc-layout/hint.md

@@ -0,0 +1,9 @@
+# Hint: indentation and interpolation are separate
+
+`<<~` strips the common leading indentation from the content while preserving
+indentation relative to other lines. `<<-` allows an indented closing delimiter
+but keeps the content indentation.
+
+Single-quote the starting delimiter to keep `#{name}` as literal text. The
+closing delimiter still uses its plain name. Once quoting is fixed, the local
+`name` assignment in `literal` is no longer needed.

data/exercises/keyword-forwarding/brief.md

@@ -0,0 +1,8 @@
+# The lost keyword
+
+Fix `forward` to preserve positional arguments, keyword arguments, and the block when calling `target`. target takes a payload, suffix: defaulting to "?", and returns the yielded payload string plus the suffix. A positional hash is still a positional payload.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `keyword_forwarding.rb` in this exercise's folder. Checks call
+`Exercises::KeywordForwarding` and its example classes.

data/exercises/keyword-forwarding/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Ruby 3 separates keyword arguments from a positional final hash.
+
+Forward each argument category separately, or use the argument-forwarding shorthand.

data/exercises/keyword-forwarding/keyword_forwarding.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# The example deliberately contrasts received arguments with values actually used.
+# The block name is observable through parameter metadata or the explicit forwarding example.
+# The exercise makes positional, keyword, and block forwarding visible.
+# rubocop:disable Lint/UnusedMethodArgument, Naming/BlockForwarding, Style/ArgumentsForwarding
+
+module Exercises
+  # Fix forward to preserve positional arguments, keyword arguments, and the block when calling
+  # target.
+  class KeywordForwarding
+    # Renders one positional payload with an optional block and suffix.
+    # @return [String]
+    def self.target(payload, suffix: '?')
+      rendered = block_given? ? yield(payload) : payload.to_s
+      rendered + suffix
+    end
+
+    # Forwards positional arguments, keywords, and the block to target.
+    # @return [String]
+    def self.forward(*args, **keywords, &block)
+      target(*args, &block)
+    end
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument, Naming/BlockForwarding, Style/ArgumentsForwarding

data/exercises/lazy-enumeration/brief.md

@@ -0,0 +1,8 @@
+# An endless queue
+
+Implement `first_multiples(limit)` to return the first limit positive multiples of seven, starting at seven, using the endless range `(1..)`. Do not materialize the endless sequence. Zero returns [].
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `lazy_enumeration.rb` in this exercise's folder. Checks call
+`Exercises::LazyEnumeration` and its example classes.

data/exercises/lazy-enumeration/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+An endless sequence requires a finite consumer.
+
+lazy defers selecting until elements are requested.

data/exercises/lazy-enumeration/lazy_enumeration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# The example deliberately contrasts received arguments with values actually used.
+# rubocop:disable Lint/UnusedMethodArgument
+
+module Exercises
+  # Implement first_multiples(limit) to return the first limit positive multiples of seven, starting
+  # at seven, using the endless range (1..).
+  class LazyEnumeration
+    # Takes the requested number of multiples from a lazy infinite sequence.
+    # @return [Array<Integer>]
+    def self.first_multiples(limit) = (1..).lazy.select { |n| (n % 7).zero? }.first(3)
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument

data/exercises/literals-and-operators/brief.md

@@ -0,0 +1,20 @@
+# Truthy zero, tricky operators
+
+Fill `predictions` for these expressions: `!!0`, `5 / 2`, `5 / 2.0`, `1 + 2 * 3`, `!nil`, `%w[ruby rails]`, and `(1..3).to_a`. The keys are zero_truthy, integer_division, float_division, precedence, not_nil, words, range. Implement `default_for_nil(value)` to substitute "missing" only for nil, preserving false and zero.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `literals_and_operators.rb` in this exercise's folder. Checks call
+`Exercises::LiteralsAndOperators` and its example classes.
+
+Use these expressions for the prediction fields, in order:
+
+```ruby
+0 ? true : false
+5 / 2
+5.0 / 2
+1 + 2 * 3
+!nil
+%w[ruby rails]
+(1..3).to_a
+```

data/exercises/literals-and-operators/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Only nil and false are falsey in Ruby.
+
+Integer division and floating-point division have different results; multiplication binds before addition.

data/exercises/literals-and-operators/literals_and_operators.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Exercises
+  # Fill predictions for these expressions: !!0, 5 / 2, 5 / 2.0, 1 + 2 * 3, !nil, %w[ruby rails], and (1..3).to_a.
+  class LiteralsAndOperators
+    # Implements predictions.
+    def self.predictions
+      { zero_truthy: false, integer_division: 2.5, float_division: 2, precedence: 9, not_nil: false, words: [],
+        range: [] }
+    end
+
+    # Implements default for nil.
+    def self.default_for_nil(value) = value || 'missing'
+  end
+end

data/exercises/method-contracts/brief.md

@@ -0,0 +1,8 @@
+# The method’s contract
+
+Fix `format_order(name, quantity=1, *extras, unit:, **options, &block)` to return "name:quantity:unit:extra_count:priority" where priority defaults to "normal". If a block is supplied, pass the formatted string to it. Implement `parameters` by exposing the actual method parameter metadata. Keep the declared signature intact.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `method_contracts.rb` in this exercise's folder. Checks call
+`Exercises::MethodContracts` and its example classes.

data/exercises/method-contracts/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Defaults, splats, keywords, and a block are separate parts of a Ruby method contract.
+
+The options hash contains extra keywords; Method#parameters exposes signature details.

data/exercises/method-contracts/method_contracts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# The example deliberately contrasts received arguments with values actually used.
+# rubocop:disable Lint/UnusedMethodArgument
+
+module Exercises
+  # Fix format_order(name, quantity=1, *extras, unit:, **options, &block) to return
+  # "name:quantity:unit:extra_count:priority" where priority defaults to "normal".
+  class MethodContracts
+    # Formats positional, rest, and keyword options, then applies an optional block.
+    # @return [String]
+    def self.format_order(name, quantity = 1, *extras, unit:, **options, &block)
+      "#{name}:#{quantity}:#{unit}:#{extras.size}:normal"
+    end
+
+    # Reports the parameter kinds and names of format_order.
+    # @return [Array<Array<Symbol>>]
+    def self.parameters = []
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument

data/exercises/method-lookup/brief.md

@@ -0,0 +1,8 @@
+# A wrapper before the class
+
+Presenter.new.call returns "base". Wrapper#call adds square brackets around super. Fix composition so the wrapper runs before Presenter without replacing the base method. `lookup` should return the names of the first two ancestors: Exercises::MethodLookup::Wrapper, Exercises::MethodLookup::Presenter.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `method_lookup.rb` in this exercise's folder. Checks call
+`Exercises::MethodLookup` and its example classes.

data/exercises/method-lookup/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+include and prepend place a module on different sides of the class in method lookup.
+
+If the class defines the method, an included module’s method will be shadowed.

data/exercises/method-lookup/method_lookup.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Exercises
+  # Presenter#call returns "base".
+  class MethodLookup
+    # Example Wrapper for method lookup.
+    module Wrapper
+      # Returns the value from this scope's example receiver.
+      # @return [String]
+      def call = "[#{super}]"
+    end
+
+    # Example Presenter for method lookup.
+    class Presenter
+      include Wrapper
+
+      # Returns the value from this scope's example receiver.
+      # @return [String]
+      def call = 'base'
+    end
+
+    # Lists the first two ancestor names in method lookup order.
+    # @return [Array<String>]
+    def self.lookup = Presenter.ancestors.first(2).map(&:name)
+  end
+end

data/exercises/nonlocal-exit/brief.md

@@ -0,0 +1,8 @@
+# Who does return leave?
+
+Implement `lambda_trace` so return inside the lambda ends only that lambda, and the method still appends "after". Implement `escaped_proc` returning an ordinary proc with a nonlocal return: calling it after the defining method has returned must raise LocalJumpError. Implement `find_even` using catch/throw to stop nested traversal, returning the first even number or nil. `skip_odds` uses next to collect only even values.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `nonlocal_exit.rb` in this exercise's folder. Checks call
+`Exercises::NonlocalExit` and its example classes.

data/exercises/nonlocal-exit/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+return in an ordinary proc tries to leave its defining method; lambda return is local.
+
+catch/throw is a non-exception mechanism to leave a matching dynamic scope.

data/exercises/nonlocal-exit/nonlocal_exit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Explicit return is the subject of this example.
+# rubocop:disable Style/RedundantReturn
+
+module Exercises
+  # Implement lambda_trace so return inside the lambda ends only that lambda, and the method still
+  # appends "after".
+  class NonlocalExit
+    # Collects the lambda result and continues the surrounding method.
+    # @return [Array<String>]
+    def self.lambda_trace
+      action = -> { return 'inside' }
+      [action.call]
+    end
+
+    # Returns a proc whose later return targets this already completed method.
+    # @return [Proc]
+    def self.escaped_proc = -> { return :gone }
+    # Uses catch and throw to find the first even number across nested groups.
+    # @return [Integer, nil]
+    def self.find_even(groups) = groups.flatten.last
+    # Skips odd values while collecting the even numbers.
+    # @return [Array<Integer>]
+    def self.skip_odds(values) = values
+  end
+end
+
+# rubocop:enable Style/RedundantReturn

data/exercises/numbered-parameters/brief.md

@@ -0,0 +1,18 @@
+# No names, still parameters
+
+Implement `pair_sums` using the block’s input pairs; for [[2,3],[4,5]], return [5,9]. Explore `_1` and `_2` as alternatives to named block parameters. Fill `predictions` for whether these parse: `[1].map { |n| _1 }` and `[[1,2]].map { _1 + _2 }`. Return explicit_and_numbered and numbered_pair booleans.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `numbered_parameters.rb` in this exercise's folder. Checks call
+`Exercises::NumberedParameters` and its example classes.
+
+For the syntax predictions, compare these blocks:
+
+```ruby
+# explicit_and_numbered: can explicit names and numbered parameters be mixed?
+# [[2, 3]].map { |left, right| _1 + _2 }
+
+# numbered_pair: does this block receive both components of each pair?
+[[2, 3]].map { _1 + _2 }
+```

data/exercises/numbered-parameters/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Numbered parameters are inferred when a block has no explicit parameter list.
+
+Using _2 also introduces _1; pairs can be destructured into the inferred parameters.

data/exercises/numbered-parameters/numbered_parameters.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# These example blocks expose arguments even when the example does not consume them.
+# rubocop:disable Lint/UnusedBlockArgument
+
+module Exercises
+  # Implement pair_sums using the block’s input pairs; for [[2,3],[4,5]], return [5,9].
+  class NumberedParameters
+    # Adds both components of each pair using numbered parameters.
+    # @return [Array<Integer>]
+    def self.pair_sums(pairs) = pairs.map { |left, right| left }
+    # Returns predictions for the expressions described in the brief.
+    # @return [Hash<Symbol, Object>]
+    def self.predictions = { explicit_and_numbered: true, numbered_pair: false }
+  end
+end
+
+# rubocop:enable Lint/UnusedBlockArgument

data/exercises/numeric-precision/brief.md

@@ -0,0 +1,8 @@
+# One third is not zero
+
+Implement `ratios(a,b)` returning integer division, floating division, and exact Rational division under keys integer, floating, rational. Implement `imaginary_product(a,b)` for (a*i)*(b*i), returning Complex. Preserve exact Rational arithmetic when adding one.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `numeric_precision.rb` in this exercise's folder. Checks call
+`Exercises::NumericPrecision` and its example classes.

data/exercises/numeric-precision/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Integer division truncates for integer operands; Float approximates; Rational can remain exact.
+
+Changing the operand type changes the division operation.

data/exercises/numeric-precision/numeric_precision.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# The original descriptive check identifiers and example strings remain intact.
+# Short parameter names match the small arithmetic or assignment examples.
+# rubocop:disable Layout/LineLength, Naming/MethodParameterName
+
+module Exercises
+  # Implement ratios(a,b) returning integer division, floating division, and exact Rational division under keys integer, floating, rational.
+  class NumericPrecision
+    # Implements ratios.
+    def self.ratios(a, b) = { integer: a / b, floating: a / b, rational: a / b }
+    # Implements imaginary product.
+    def self.imaginary_product(a, b) = Complex(a * b, 0)
+  end
+end
+
+# rubocop:enable Layout/LineLength, Naming/MethodParameterName

data/exercises/pattern-matching/brief.md

@@ -0,0 +1,8 @@
+# A payload with a pin
+
+Implement `amount(payload, kind)` to return a positive Integer amount only when a hash has type equal to the supplied kind and amount is an Integer greater than zero. Extra keys are allowed. Otherwise return nil. Practice a pinned variable and a guard in a pattern.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `pattern_matching.rb` in this exercise's folder. Checks call
+`Exercises::PatternMatching` and its example classes.

data/exercises/pattern-matching/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+An underscore matches a value without checking it against your variable.
+
+Pin the existing kind value with ^kind, and add a guard for positivity.

data/exercises/pattern-matching/pattern_matching.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# The example deliberately contrasts received arguments with values actually used.
+# rubocop:disable Lint/UnusedMethodArgument
+
+module Exercises
+  # Implement amount(payload, kind) to return a positive Integer amount only when a hash has type
+  # equal to the supplied kind and amount is an Integer greater than zero.
+  class PatternMatching
+    # Implements amount.
+    def self.amount(payload, kind)
+      case payload
+      in { type: _, amount: Integer => number }
+        number
+      else
+        nil
+      end
+    end
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument

data/exercises/refinement-scope/brief.md

@@ -0,0 +1,8 @@
+# A local voice
+
+Speaker#say normally returns "plain". A refinement should change it to "local" only in Exercises::RefinementScope::Local.call, which activates the refinement lexically. Exercises::RefinementScope.outside must still return "plain". Fix activation without globally reopening Speaker.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `refinement_scope.rb` in this exercise's folder. Checks call
+`Exercises::RefinementScope` and its example classes.

data/exercises/refinement-scope/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+Defining a refinement does not activate it everywhere.
+
+using activates a refinement in its lexical scope; it is not an ordinary runtime toggle inside a method.

data/exercises/refinement-scope/refinement_scope.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Exercises
+  # Speaker#say normally returns "plain".
+  class RefinementScope
+    # Example Speaker for refinement scope.
+    class Speaker
+      # Returns the voice selected by the lexical refinement scope.
+      # @return [String]
+      def say = 'plain'
+    end
+
+    # Example Voice for refinement scope.
+    module Voice
+      refine Speaker do
+        # Returns the voice selected by the lexical refinement scope.
+        # @return [String]
+        def say = 'local'
+      end
+    end
+
+    # Example Local for refinement scope.
+    module Local
+      # Returns the value from this scope's example receiver.
+      # @return [String]
+      def self.call = Speaker.new.say
+    end
+
+    # Returns the unrefined voice outside the local scope.
+    # @return [String]
+    def self.outside = Speaker.new.say
+  end
+end

data/exercises/regexp-captures/brief.md

@@ -0,0 +1,8 @@
+# The newline loophole
+
+Implement `parse(text)` for an entire string of lowercase name, colon, and decimal digits. Return {name: String,id: Integer}, or nil for any other input. Reject trailing newlines and multiple lines. Implement `probe(text)` so /ruby/ matching returns a boolean while preserving a previously established match for "old" in its own scope.
+
+Use `rkoans check` to investigate one failing check at a time. Hints are optional.
+
+Edit `regexp_captures.rb` in this exercise's folder. Checks call
+`Exercises::RegexpCaptures` and its example classes.

data/exercises/regexp-captures/hint.md

@@ -0,0 +1,5 @@
+# Hint
+
+^ and $ anchor lines; \A and \z anchor the whole string.
+
+Named captures are strings even when they contain digits.

data/exercises/regexp-captures/regexp_captures.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# The starter compares boolean coercion of match with match? while observing capture changes.
+# The example explicitly observes the regexp capture variable.
+# rubocop:disable Style/DoubleNegation, Style/SpecialGlobalVars
+
+module Exercises
+  # Implement parse(text) for an entire string of lowercase name, colon, and decimal digits.
+  class RegexpCaptures
+    # Implements parse.
+    def self.parse(text)
+      match = /^(?<name>[a-z]+):(?<id>\d+)$/.match(text)
+      match && { name: match[:name], id: match[:id] }
+    end
+
+    # Implements probe.
+    def self.probe(text)
+      /old/.match('old')
+      matched = !!/ruby/.match(text)
+      [$~&.to_s, matched]
+    end
+  end
+end
+
+# rubocop:enable Style/DoubleNegation, Style/SpecialGlobalVars

data/exercises/runtime-context/brief.md

@@ -0,0 +1,20 @@
+# Where am I running?
+
+Implement `Exercises::RuntimeContext.context` using the process's actual `ARGV`,
+`ENV['RKOANS_GREETING']`, `$PROGRAM_NAME`, `__FILE__`, `__ENCODING__`, and `RUBY_VERSION`.
+
+Return a hash with these keys:
+
+- `arguments`: a copy of the current arguments, without consuming or changing `ARGV`.
+- `greeting`: the environment value, or `nil` when that key is absent.
+- `program`: the basename of the entry-point file.
+- `file`: the basename of the file containing `context`.
+- `encoding`: the source encoding's name.
+- `ruby`: the running Ruby version.
+
+The checks run this file through a separate entry point, so `program` and `file`
+describe different files. Each check controls its own arguments and environment;
+you do not need to configure your shell. Changing the returned `arguments` array
+must leave `ARGV` unchanged.
+
+Save your file to rerun the checks automatically.

data/exercises/runtime-context/hint.md

@@ -0,0 +1,8 @@
+# Hint: process inputs and source context
+
+`ARGV` contains command-line arguments; `ENV` exposes environment entries.
+Reading a missing environment key returns `nil`.
+
+`__FILE__` identifies the source file containing the expression, while
+`$PROGRAM_NAME` identifies the entry point. Use `File.basename` to keep only
+their filenames. Think about how to return an array without sharing its mutations.