get-smart 0.0.1

data/files/ruby/irb/advanced/multi_irb_sessions.md

@@ -0,0 +1,10 @@
+## 🚀 Running Multiple IRB Sessions in One Process
+
+IRB 1.3+ supports `--multi-irb` to spawn multiple consoles sharing the same VM. This allows you to inspect state in parallel contexts without reloading code.
+
+```bash
+# Launch a multi-IRB master console
+irb --multi-irb
+# In another terminal, attach a new session to the same VM
+irb --multi-irb --attach=master
+```

data/files/ruby/irb/advanced/persist_command_history.md

@@ -0,0 +1,11 @@
+## 📜 Persisting Command History Across Sessions
+
+By default IRB saves only the last 100 lines of history per session. You can configure it to store thousands of commands and merge with existing history on startup. This makes recalling previous explorations a breeze.
+
+```ruby
+# ~/.irbrc
+require 'irb/ext/save-history'
+IRB.conf[:HISTORY_FILE] = "~/.irb_history"
+IRB.conf[:SAVE_HISTORY] = 5_000  # keep last 5000 commands
+IRB.conf[:AUTO_SAVE_HISTORY] = true
+```

data/files/ruby/irb/advanced/save_load_workspace.md

@@ -0,0 +1,13 @@
+## 💾 Saving and Restoring IRB Workspaces
+
+Persist your session’s workspace variables and reload them later to pick up right where you left off. Use `IRB.conf[:SAVE_WORKSPACE]` and `IRB.load` to serialize and deserialize your session.
+
+```ruby
+# ~/.irbrc
+IRB.conf[:SAVE_WORKSPACE] = true
+IRB.conf[:WORKSPACE_FILE] = "~/.irb_workspace"
+# Then at exit:
+# IRB.save_workspace
+# At start:
+# IRB.load_workspace
+```

data/files/ruby/irb/advanced/use_pry_shell.md

@@ -0,0 +1,15 @@
+## 🔍 Using Pry Commands Inside IRB
+
+You can drop into a Pry REPL without leaving your IRB session by requiring Pry and invoking it directly. This hybrid approach lets you benefit from both tools in one console.
+
+```ruby
+# ~/.irbrc
+begin
+  require 'pry'
+  IRB.conf[:MAGIC_WORDS]['/pry'] = proc { binding.pry }
+rescue LoadError
+  warn 'Install pry to enable /pry command'
+end
+# Usage:
+# /pry
+```

data/files/ruby/irb/beginner/access_ruby_docs.md

@@ -0,0 +1,9 @@
+## 📖 Accessing Ruby Docs with `ri`
+
+You don’t need to leave IRB to check the documentation for a class or method. Just type `ri` followed by the constant or method name:
+
+```ruby
+irb(main):001:0> ri Array
+```
+
+This displays the RDoc documentation for `Array` directly in your console.

data/files/ruby/irb/beginner/exit_irb.md

@@ -0,0 +1,8 @@
+## 🚪 Exiting IRB Gracefully
+
+To leave IRB when you’re done, you have two simple options: type `exit` or press `Ctrl + D`. Both will close the session and return you to your shell:
+
+```ruby
+irb(main):001:0> exit
+$ 
+```

data/files/ruby/irb/beginner/grep_methods.md

@@ -0,0 +1,9 @@
+## 🎯 Filtering Methods with `grep`
+
+If an object has too many methods, use `grep` to narrow them down by pattern. For example, to find all enumerable methods:
+
+```ruby
+irb(main):001:0> (1..5).methods.grep(/map|select/)
+```
+
+This returns only methods matching `map` or `select`, making discovery faster.

data/files/ruby/irb/beginner/history_navigation.md

@@ -0,0 +1,9 @@
+## 🔄 Navigating Command History
+
+IRB saves your previous commands, letting you quickly recall them with the Up/Down arrow keys. You can also perform a reverse search by pressing `Ctrl + R` and typing part of a past command:
+
+```ruby
+(reverse-i-search)`puts': puts 'Hello, world!'
+```
+
+Press Enter to execute the found command or continue typing to refine your search.

data/files/ruby/irb/beginner/launch_irb.md

@@ -0,0 +1,13 @@
+## 💡 Launching IRB
+
+IRB is the interactive Ruby shell that lets you experiment with Ruby code in real time without creating a file. To start IRB, simply run:
+
+```ruby
+$ irb
+```
+
+You can also check which Ruby version IRB is using:
+
+```ruby
+$ irb --version
+```

data/files/ruby/irb/beginner/list_methods.md

@@ -0,0 +1,9 @@
+## 🔍 Listing Available Methods
+
+To see what methods an object responds to, call `methods` on it. This is handy to discover available operations at a glance:
+
+```ruby
+irb(main):001:0> "hello".methods
+```
+
+You’ll get an array of all public methods you can call on the string.

data/files/ruby/irb/beginner/load_ruby_file.md

@@ -0,0 +1,9 @@
+## 📂 Loading External Ruby Files
+
+When you’re testing code from another file, use `load` to re-read it every time you change it. Unlike `require`, `load` will reload the file on each call, which is great for quick iterations:
+
+```ruby
+irb(main):001:0> load 'my_script.rb'
+```
+
+This executes `my_script.rb` in the current session so you can immediately test your updates.

data/files/ruby/irb/beginner/multiline_code.md

@@ -0,0 +1,10 @@
+## ✏️ Writing Multi-line Code
+
+When defining methods or writing longer blocks, IRB automatically enters multi-line mode after a code delimiter. You can also use a backslash `\` to continue a line:
+
+```ruby
+irb(main):001:0> long_string = "This is a \
+irb-friendly multi-line string"
+```
+
+Press Enter on an empty line to execute the whole block.

data/files/ruby/irb/beginner/persist_history.md

@@ -0,0 +1,12 @@
+## 💾 Persisting Command History
+
+By default, IRB saves your history between sessions if you enable it in `~/.irbrc`. Add the following to your `.irbrc` to keep the last 1000 commands:
+
+```ruby
+# ~/.irbrc
+require 'irb/ext/save-history'
+IRB.conf[:SAVE_HISTORY] = 1000
+IRB.conf[:HISTORY_FILE] = "~/.irb_history"
+```
+
+Now every command you run will be saved across sessions.

data/files/ruby/irb/beginner/shell_commands.md

@@ -0,0 +1,11 @@
+## 💻 Running Shell Commands with `!`
+
+Prefix commands with `!` to run shell commands without leaving IRB. This is handy for checking files or directory contents on the fly:
+
+```ruby
+irb(main):001:0> !pwd
+/home/user/projects
+irb(main):002:0> !ls -al
+```
+
+The output appears right in your IRB session.

data/files/ruby/irb/expert/benchmark_integration.md

@@ -0,0 +1,15 @@
+## ⏱️ Automatic Benchmarking Wrapper
+Wrap each entered expression in a `Benchmark.measure` to instantly see performance metrics for your exploratory code.
+
+```ruby
+require 'benchmark'
+module IRB
+  class InputTransformer
+    def transform(line)
+      "Benchmark.measure { #{line} }.tap { |bm| puts bm }"
+    end
+  end
+end
+```
+
+Every time you type an expression, IRB prints the elapsed time, allocations, and GC stats. Tweak the transformer to filter heavy operations and suppress trivial ones.

data/files/ruby/irb/expert/context_switching.md

@@ -0,0 +1,21 @@
+## 🔄 IRB Workspace Context Switching
+Switch between multiple bindings (contexts) on the fly, letting you inspect different scopes without leaving IRB.
+
+```ruby
+require 'irb'
+
+@ctx1 = binding
+@foo = 42
+
+@ctx2 = TOPLEVEL_BINDING
+
+def switch_to(ctx)
+  IRB.start_within(ctx)
+end
+
+# In IRB:
+switch_to(@ctx1)  # Now sees @foo
+switch_to(@ctx2)  # Back to top-level
+```
+
+Use `IRB.start_within(binding)` to reopen a REPL in any binding, enabling seamless context hops.

data/files/ruby/irb/expert/dsl_auto_completion.md

@@ -0,0 +1,23 @@
+## 🧩 Custom DSL Auto-Completion
+Add domain-specific auto-completion for your DSL classes or methods by extending the IRB completer. This dramatically speeds exploratory coding.
+
+```ruby
+require 'irb/completion'
+module IRB
+  module Completion
+    def self.custom_completions
+      %w[find_by_name find_by_email find_by_id]
+    end
+    alias original_complete complete
+    def complete(line)
+      if line =~ /^User\.find_by_/
+        custom_completions.grep(/^#{Regexp.escape(line.split('.').last)}/)
+      else
+        original_complete(line)
+      end
+    end
+  end
+end
+```
+
+Now typing `User.find_by_` in IRB will suggest your custom methods.

data/files/ruby/irb/expert/dynamic_git_prompt.md

@@ -0,0 +1,17 @@
+## 🚀 Dynamic Git-Aware Prompt
+Display branch, status and timing in your IRB prompt to stay context-aware. By customizing `IRB.conf[:PROMPT]`, you can show Git information inline.
+
+```ruby
+require 'irb'
+require 'open3'
+
+IRB.conf[:PROMPT][:GIT] = {
+  PROMPT_I: "#{`git rev-parse --abbrev-ref HEAD`.strip} %03n:%i> ",
+  PROMPT_S: nil,
+  PROMPT_C: nil,
+  RETURN: "=> %s\n"
+}
+IRB.conf[:PROMPT_MODE] = :GIT
+```
+
+This runs on each prompt, fetching the current branch. You can extend the shell call to show dirty state via `git status --porcelain`.

data/files/ruby/irb/expert/history_incremental_search.md

@@ -0,0 +1,15 @@
+## 🔍 Advanced Incremental History Search
+Leverage Readline's incremental search to quickly find previous commands without leaving IRB. By binding `Ctrl-R` to `history_search_backward`, you can jump directly to matching entries.
+
+Add this to your `~/.irbrc`:
+
+```ruby
+require 'readline'
+Readline.define_history_proc { |line| line.strip.empty? ? false : true }
+Readline.emacs_editing_mode
+Readline::HISTORY.to_a      # inspect history
+# Bind Ctrl-R to reverse incremental search
+Readline.rl_bind_key("\C-r") { Readline::history_search_backward }
+```
+
+Now within IRB, hit `Ctrl-R` and type part of a previous command to instantly recall it.

data/files/ruby/irb/expert/input_preprocessor.md

@@ -0,0 +1,19 @@
+## 🛠️ Preprocess and Transform Input
+Intercept and transform user input before IRB evaluates it. Useful for auto-wrapping methods or injecting debugging hooks.
+
+```ruby
+module IRB
+  class InputTransformer
+    def transform(line)
+      # Auto-wrap single-line `foo` calls in puts for quick inspection
+      if line.strip =~ /^\w+$/
+        "puts(#{line.strip})"
+      else
+        super
+      end
+    end
+  end
+end
+```
+
+Place this in `~/.irbrc` to automatically wrap bare identifiers in `puts`. You can use this hook to inject logging, profiling, or custom DSL expansion.

data/files/ruby/irb/expert/magic_commands_extension.md

@@ -0,0 +1,21 @@
+## ✨ Extending IRB with Magic Commands
+Implement custom `%`-prefixed commands (à la IPython) for repetitive tasks like reloading, schema introspection, or database queries.
+
+```ruby
+module IRB
+  module ExtendCommandBundle
+    def reload_models
+      Dir["app/models/*.rb"].each { |f| load f }
+      puts "Models reloaded"
+    end
+    def schema(table)
+      ActiveRecord::Base.connection.columns(table).map(&:name)
+    end
+  end
+end
+IRB.conf[:IRB_RC] = proc do |conf|
+  conf.extend IRB::ExtendCommandBundle
+end
+```
+
+Now, in IRB, run `reload_models` or `schema('users')` as top-level commands without parentheses.

data/files/ruby/irb/expert/programmatic_irb_control.md

@@ -0,0 +1,18 @@
+## ⚙️ Programmatic IRB Session Control
+Embed IRB sessions in your scripts and control their lifecycle. This is essential for building custom consoles or REPL-based tools.
+
+```ruby
+require 'irb'
+require 'irb/ext/multi-irb'
+
+thread1 = Thread.new do
+  IRB.start(__FILE__, binding)
+end
+thread2 = Thread.new do
+  IRB.start(__FILE__, TOPLEVEL_BINDING)
+end
+
+[thread1, thread2].each(&:join)
+```
+
+Here, two IRB sessions run concurrently in separate threads. You can programmatically start, stop, or broadcast code to them by leveraging `IRB.CurrentContext`.

data/files/ruby/irb/expert/sandboxed_session.md

@@ -0,0 +1,17 @@
+## 🛡️ Sandboxed IRB with Safe Levels
+Run untrusted code or plugins within a restricted IRB session by leveraging Ruby's `$SAFE` levels (MRI ≤2.6) or `Sandbox` gems for modern versions.
+
+```ruby
+require 'sandbox'
+sb = Sandbox.new
+sb.eval('File.write("/tmp/hacked", "oops")')    # blocked by sandbox
+sb.eval('2 + 2')                                    # => 4
+
+# For MRI ≤2.6, you can also:
+Thread.new do
+  $SAFE = 3
+  eval("File.read('/etc/passwd')")               # raises SecurityError
+end.join
+```
+
+This isolates evaluation contexts, preventing file system or system call escapes. Use it when loading third‑party IRB extensions.

data/files/ruby/irb/expert/threaded_debugging.md

@@ -0,0 +1,18 @@
+## 🧠 Multi-Threaded Debugging with binding.irb
+Insert `binding.irb` in concurrent code paths to drop into IRB with the current thread's context. This is invaluable for dissecting race conditions.
+
+```ruby
+require 'irb'
+
+threads = 3.times.map do |i|
+  Thread.new do
+    sleep rand
+    puts "Thread #{i} before debug"
+    binding.irb  # REPL in this thread
+    puts "Thread #{i} after debug"
+  end
+end
+threads.each(&:join)
+```
+
+When execution hits `binding.irb`, you get a full REPL locked to that thread. Inspect local vars, step through state, then type `exit` to resume.

data/files/ruby/irb/middle/auto_require_gems.md

@@ -0,0 +1,8 @@
+## 📦 Auto-Require Gems
+Load frequently used libraries automatically on startup. This saves you from typing `require` each time you open IRB.
+
+```ruby
+# ~/.irbrc
+auto_requires = %w[pry awesome_print dotenv]
+auto_requires.each { |gem_name| require gem_name }
+```

data/files/ruby/irb/middle/awesome_print_output.md

@@ -0,0 +1,13 @@
+## ✨ Format Output with AwesomePrint
+Use the `awesome_print` gem for more readable inspection of complex objects. Monkey-patch IRB’s output to call `ap` instead of the default inspect.
+
+```ruby
+# ~/.irbrc
+require 'awesome_print'
+
+IRB::Irb.class_eval do
+  def output_value
+    ap @context.last_value
+  end
+end
+```

data/files/ruby/irb/middle/binding_irb_hook.md

@@ -0,0 +1,12 @@
+## 🚀 Drop into IRB with binding.irb
+Use `binding.irb` in your scripts to launch an IRB session at runtime. This is perfect for debugging or exploring state in the middle of execution.
+
+```ruby
+# example_script.rb
+require 'irb'
+require 'irb/completion'
+
+puts "Before debugging"
+binding.irb  # execution stops here and opens IRB
+puts "After debugging"
+```

data/files/ruby/irb/middle/custom_inspector.md

@@ -0,0 +1,8 @@
+## 🖼 Customize the Inspector
+Adjust IRB’s built‑in inspector to use pretty or colored output. This improves readability without external gems.
+
+```ruby
+# ~/.irbrc
+IRB.conf[:INSPECT_MODE] = :pretty    # uses PrettyPrint (pretty_inspect)
+IRB.conf[:ECHO]         = true       # show evaluated code
+```

data/files/ruby/irb/middle/custom_irb_commands.md

@@ -0,0 +1,12 @@
+## 🔧 Define Custom IRB Commands
+Extend IRB with your own commands for repetitive tasks. Here’s how to add a `my_ls` command that lists directory contents.
+
+```ruby
+# ~/.irbrc
+module IRB::ExtendCommandBundle
+  def my_ls(path = '.')
+    puts Dir.entries(path)
+  end
+end
+```
+Now inside IRB call `my_ls 'lib'` to quickly inspect files.

data/files/ruby/irb/middle/custom_prompt.md

@@ -0,0 +1,13 @@
+## 🎨 Customize the Prompt
+A custom prompt can convey context like the current directory or Git branch. Define a new prompt mode in your `~/.irbrc` and switch to it for a tailored REPL experience.
+
+```ruby
+# ~/.irbrc
+IRB.conf[:PROMPT][:MIDDLE] = {
+  PROMPT_I: "\033[1;32m>> \033[0m",   # main prompt
+  PROMPT_S: "\033[1;33m?  \033[0m",   # continued string
+  PROMPT_C: "\033[1;31m*  \033[0m",   # continued expression
+  RETURN:   "=> %s\n"                # return value
+}
+IRB.conf[:PROMPT_MODE] = :MIDDLE
+```

data/files/ruby/irb/middle/pager_output.md

@@ -0,0 +1,8 @@
+## 📖 Paginate Long Output
+For large arrays or hashes, enable a pager so output scrolls in a `less` view. This prevents your terminal from flooding with too much text.
+
+```ruby
+# ~/.irbrc
+require 'irb/pager'
+IRB.conf[:PAGER] = 'less -R'
+```

data/files/ruby/irb/middle/persistent_history.md

@@ -0,0 +1,8 @@
+## 💾 Enable Persistent History
+By default, IRB doesn’t remember your commands between sessions. You can enable history persistence by configuring the history file path and maximum entries in your `~/.irbrc` so you can search past commands later.
+
+```ruby
+# ~/.irbrc
+IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb_history"
+IRB.conf[:SAVE_HISTORY]   = 1000  # keep last 1000 commands
+```

data/files/ruby/irb/middle/readline_key_bindings.md

@@ -0,0 +1,9 @@
+## 🔑 Customize Readline Key Bindings
+Improve history navigation by binding arrow keys to prefix searches. This allows you to type part of a command and hit ↑/↓ to cycle through matching history entries.
+
+```ruby
+# ~/.irbrc
+require 'readline'
+Readline.rl_parse_and_bind('"\e[A": history-search-backward')
+Readline.rl_parse_and_bind('"\e[B": history-search-forward')
+```

data/files/ruby/irb/middle/tab_completion.md

@@ -0,0 +1,7 @@
+## 🔍 Enable Tab Completion
+IRB can autocomplete methods, constants, and file names via Readline. Simply require the completion library in your `~/.irbrc` to boost productivity.
+
+```ruby
+# ~/.irbrc
+require 'irb/completion'
+```

data/files/ruby/json/advanced/custom_generator_state_for_json.md

@@ -0,0 +1,27 @@
+## 🛠️ Extending JSON::Ext::Generator::State for Custom Serialization
+
+For low-level control over JSON output—such as tweaking whitespace, injecting metadata, or handling circular references—subclass JSON::Ext::Generator::State. Override methods like `array`, `hash`, or `generate_value` to implement complex serialization logic.
+
+```ruby
+require 'json'
+
+class PrettyState < JSON::Ext::Generator::State
+  def initialize(options = {})
+    super
+    self.space = " "            # Space after colon
+    self.space_before = ""      # No space before colon
+    self.object_nl = "\n"      # Newline after object
+    self.array_nl = "\n"       # Newline after array elements
+  end
+
+  # Insert a custom header before root object
+  def generate(object)
+    write("/* Generated at: #{Time.now.utc} */\n")
+    super
+  end
+end
+
+data = {name: 'Alice', scores: [10, 20, 30]}
+json = JSON.generate(data, state: PrettyState.new)
+puts json
+```

data/files/ruby/json/advanced/high_performance_parsing_with_oj.md

@@ -0,0 +1,21 @@
+## 🚀 High-Performance Parsing and Serialization with Oj
+
+For ultra-fast JSON processing in Ruby, the Oj gem offers C-backed parsing and dumping with customizable modes. Set default options to bias for your data patterns—such as symbolizing keys or loading BigDecimal natively—to reduce post-processing overhead.
+
+```ruby
+require 'oj'
+
+# Global configuration
+Oj.default_options = {
+  mode: :compat,             # Allow interop with JSON gem structures
+  symbol_keys: true,         # Convert object keys to symbols
+  bigdecimal_load: :bigdecimal # Preserve BigDecimal types
+}
+
+# Parsing large JSON strings
+data = Oj.load(json_string) # Fast C implementation
+
+# Serializing objects back to JSON
+json_output = Oj.dump(data, mode: :strict)
+puts json_output
+```

data/files/ruby/json/advanced/streaming_large_json_with_oj_schandler.md

@@ -0,0 +1,47 @@
+## 📦 Streaming Large JSON Parsing with Oj ScHandler
+
+When working with enormous JSON files that can’t fit into memory, use Oj::ScHandler for event-driven streaming. Implement callback methods to process elements as they arrive, avoiding full in-memory deserialization.
+
+```ruby
+require 'oj'
+
+class MyHandler < Oj::ScHandler
+  def initialize
+    @stack = []
+  end
+
+  def hash_start
+    @stack.push({})
+  end
+
+  def array_start
+    @stack.push([])
+  end
+
+  def add_value(value)
+    container = @stack.last
+    if container.is_a?(Array)
+      container << value
+    else
+      key, = @current_key_pair
+      container[key] = value
+    end
+  end
+
+  def hash_end
+    value = @stack.pop
+    add_value(value)
+  end
+
+  # ... implement other callbacks: array_end, add_value, hash_start etc.
+end
+
+# Stream parse in chunks
+handler = MyHandler.new
+parser = Oj::ScParser.new(handler)
+File.open('huge_data.json') do |file|
+  while chunk = file.read(8 * 1024) # 8KB chunks
+    parser << chunk
+  end
+end
+```

data/files/ruby/json/beginner/json_file_io.md

@@ -0,0 +1,17 @@
+## 📂 Read and Write JSON Files
+Combining Ruby’s `File` class with `json` makes it easy to persist data or load configurations. To read a JSON file, use `File.read` and `JSON.parse`. To write, use `File.write` along with `JSON.pretty_generate` for human-friendly formatting.
+
+```ruby
+require 'json'
+
+# Writing to a file
+data = { settings: { theme: "dark", notifications: true } }
+File.write("config.json", JSON.pretty_generate(data))
+
+# Reading from a file
+json_text = File.read("config.json")
+config = JSON.parse(json_text)
+puts config["settings"]["theme"]  # => "dark"
+```
+
+Using `pretty_generate` adds newlines and indentation, making the JSON file easy to read and edit by hand.

data/files/ruby/json/beginner/json_generate_basics.md

@@ -0,0 +1,17 @@
+## ✍️ Generate JSON from Ruby Objects
+Ruby objects like Hashes and Arrays provide a `to_json` method (after requiring `json`) to serialize them into JSON strings. This is useful when you need to send data over HTTP or store it in a JSON file.
+
+```ruby
+require 'json'
+
+user = { name: "Bob", active: true, roles: ["admin", "editor"] }
+json_output = user.to_json
+puts json_output  # => "{\"name\":\"Bob\",\"active\":true,\"roles\":[\"admin\",\"editor\"]}"
+```
+
+Alternatively, use `JSON.generate` for the same result:
+
+```ruby
+json_output2 = JSON.generate(user)
+puts json_output2 == json_output  # => true
+```

data/files/ruby/json/beginner/json_parse_basics.md

@@ -0,0 +1,19 @@
+## 🛠️ Parse JSON Strings into Ruby Objects
+Parsing JSON data is straightforward with Ruby’s built-in `json` library. First, require the library and then call `JSON.parse` on a JSON-formatted string to convert it into native Ruby types (hashes, arrays, strings, etc.).
+
+```ruby
+require 'json'
+
+json_str = '{"name":"Alice","age":30,"skills":["Ruby","JSON"]}'
+parsed = JSON.parse(json_str)
+puts parsed.class            # => Hash
+puts parsed["name"]         # => "Alice"
+puts parsed["skills"][1]    # => "JSON"
+```
+
+You can pass the `symbolize_names: true` option to `JSON.parse` to convert keys to symbols for more idiomatic Ruby usage:
+
+```ruby
+parsed_sym = JSON.parse(json_str, symbolize_names: true)
+puts parsed_sym[:age]         # => 30
+```