#!/usr/bin/env ruby

# --- Understanding Backticks --- 
# Backticks (``) provide the simplest method to execute a shell command 
# and capture its standard output (stdout) as a string.
# They are ideal for commands where you primarily need the result of stdout.

puts "--- Example 1: Basic Command Output Capture ---"
command_output = `ls -lh`
puts "Output of 'ls -lh':\n#{command_output}"

puts "\n--- Example 2: Capturing a simple string ---"
message = `echo "Hello from Ruby backticks!"`
puts "Echoed message: #{message}"

# --- Exit Status with Backticks ---
# Backticks DO NOT directly return the exit status. 
# Instead, they capture stdout. To get the exit status, 
# you must inspect the global variable $? (Process::Status).

puts "\n--- Example 3: Checking Exit Status after a successful command ---"
`ls /tmp` # Execute a successful command
puts "Exit status for 'ls /tmp': #{$?.exitstatus}"
puts "Command successful? #{$?.success?}"

puts "\n--- Example 4: Checking Exit Status after a failed command ---"
`ls /nonexistent_directory_123` # Execute a command that will likely fail
puts "Exit status for 'ls /nonexistent_directory_123': #{$?.exitstatus}"
puts "Command successful? #{$?.success?}"

# --- Important Considerations ---
# 1. Shell Injection Risk: Backticks pass the string directly to the shell.
#    Avoid using user-supplied input directly in backticks without sanitization.
#
# 2. No Stderr Capture: Backticks only capture stdout. Stderr goes to the console.
#    If you need to capture stderr, consider Open3.
#
# 3. Blocking Call: The Ruby script will pause execution until the shell command completes.

# --- Common Pitfalls and Best Practices ---
# Pitfall: Assuming success without checking $?.
# Best Practice: Always check $?.success? for critical operations.

# Pitfall: Using raw user input in backticks.
# Best Practice: Prefer `system()` with array arguments or `Open3` for untrusted input.

# Example of stderr output (will print to console, not captured by backticks)
puts "\n--- Example 5: Stderr output (will appear above this line in console) ---"
`cat /no_such_file_or_directory_xyz 2>&1` # Redirect stderr to stdout to capture it, a common shell trick
puts "(Note: For pure backticks, stderr goes to console by default. 
This example uses shell redirection to force stderr into stdout.)"
puts "Exit status: #{$?.exitstatus}"

# Simple user input example (DO NOT DO THIS IN PRODUCTION WITH UNTRUSTED INPUT)
# file_name = gets.chomp
# `rm #{file_name}` # DANGER: Shell injection risk!

puts "\nBackticks are powerful for simple output capture, but demand vigilance for errors and security."

#!/usr/bin/env ruby

# --- Understanding system() --- 
# The system() method executes a shell command and returns its exit status (true/false) 
# or nil if the command cannot be executed. Unlike backticks, it does NOT capture stdout.
# Its primary purpose is to run a command and act upon its success or failure.

puts "--- Example 1: Basic Command Execution and Exit Status Check ---"
puts "Executing 'ls -lh /tmp'..."
success = system("ls -lh /tmp")
if success
  puts "Command 'ls -lh /tmp' executed successfully. Exit status: #{$?.exitstatus}"
else
  puts "Command 'ls -lh /tmp' failed. Exit status: #{$?.exitstatus}"
end

puts "\n--- Example 2: Executing a command that fails ---"
puts "Executing 'ls /no_such_path'..."
success = system("ls /no_such_path")
if success
  puts "Command 'ls /no_such_path' executed successfully. Exit status: #{$?.exitstatus}"
else
  puts "Command 'ls /no_such_path' failed. Exit status: #{$?.exitstatus}"
end

# --- Security and Argument Handling with system() ---
# system() is safer for untrusted input when used with multiple arguments.
# When system() receives multiple arguments, it avoids invoking a shell 
# and directly executes the command with the provided arguments.

puts "\n--- Example 3: Shell Injection Vulnerability (DO NOT USE IN PRODUCTION with untrusted input) ---"
# Imagine 'filename' comes from user input
malicious_filename_string = "file.txt; rm -rf /" # A dangerous input
puts "(Simulated) Attempting to create a file with malicious intent (string argument)..."
# system("touch #{malicious_filename_string}") 
# ^^^ This would execute 'touch file.txt' AND 'rm -rf /' if run.
# We comment it out to prevent accidental execution.
puts "Vulnerability demonstrated: If this were active, 'rm -rf /' could execute."

puts "\n--- Example 4: Secure Argument Handling with Array Arguments ---"
# Using an array of arguments prevents shell interpretation.
# The first element is the command, subsequent elements are arguments.
puts "Attempting to create a file with malicious intent (array argument)..."
system("touch", "#{malicious_filename_string}")

# Check if the command actually created a file named "file.txt; rm -rf /"
# (It shouldn't have executed 'rm', but might have created a strange file name)
if $?.success?
  puts "Command succeeded, file created with exact (malicious) name. #{$?.exitstatus}"
  system("rm", "#{malicious_filename_string}") # Clean up if it created the file
else
  puts "Command failed as expected due to filename issues or permissions. #{$?.exitstatus}"
end
puts "Security benefit: 'rm -rf /' was NOT executed."

# --- Blocking Behavior ---
# Like backticks, system() is a blocking call. 
# The script waits for the external command to finish.

puts "\n--- Example 5: Blocking behavior demonstration ---"
puts "Starting a 'sleep 2' command..."
system("sleep", "2")
puts "'sleep 2' command finished. Script continues."

puts "\nsystem() is crucial for executing commands where success/failure is key, especially with secure array arguments."

#!/usr/bin/env ruby
require 'open3'

# --- Understanding Open3 --- 
# Open3 is Ruby's most powerful module for interacting with external processes.
# It provides granular control over stdin, stdout, and stderr streams,
# allowing for bidirectional communication and robust error handling.
# It's ideal for complex interactions, pipes, and when explicit stream management is required.

puts "--- Example 1: Capturing stdout and stderr with Open3.capture3 ---"
# capture3 executes a command and captures its stdout, stderr, and exit status.
# It's synchronous and waits for the command to finish.

command = "ls -lh /tmp; echo 'Error message on stderr' >&2; exit 1"
puts "Executing: '#{command}'"
stdout_str, stderr_str, status = Open3.capture3(command)

puts "\nSTDOUT:\n#{stdout_str}"
puts "\nSTDERR:\n#{stderr_str}"
puts "Exit Status: #{status.exitstatus}"
puts "Successful? #{status.success?}"

if status.success?
  puts "Command executed successfully."
else
  puts "Command failed."
end

puts "\n--- Example 2: Secure Argument Handling with capture3 ---"
# Like system(), Open3.capture3 accepts multiple arguments to bypass the shell.
# This is the recommended approach for untrusted input.

puts "Executing 'ls' with arguments ['-lh', '/etc'] securely..."
stdout_secure, stderr_secure, status_secure = Open3.capture3("ls", "-lh", "/etc")
puts "\nSTDOUT (secure):\n#{stdout_secure}"
puts "Exit Status (secure): #{status_secure.exitstatus}"

puts "\n--- Example 3: Bidirectional communication with Open3.popen3 ---"
# popen3 allows you to get file descriptors for stdin, stdout, and stderr,
# enabling you to write to the command's stdin and read from its stdout/stderr.
# This is powerful for commands that expect input.

# We will pipe some text into 'grep' to filter it.
puts "Opening a pipe to 'grep ruby' and writing content..."

Open3.popen3('grep', 'ruby') do |stdin, stdout, stderr, wait_thr|
  # Write to stdin of the 'grep' command
  stdin.puts "Hello, world!"
  stdin.puts "Ruby is awesome."
  stdin.puts "Python is also cool."
  stdin.close # Important: Close stdin to signal EOF to grep

  # Read from stdout of the 'grep' command
  output = stdout.read
  error_output = stderr.read
  status_popen3 = wait_thr.value # The Process::Status object

  puts "\nOutput from grep:\n#{output}"
  puts "Error from grep:\n#{error_output}"
  puts "Exit Status for grep: #{status_popen3.exitstatus}"
end

puts "\nOpen3 empowers granular process control, vital for complex interactions."

#!/usr/bin/env ruby
require 'open3'

# --- Best Practices for Secure and Robust Shell Interaction ---

puts "--- 1. Prioritize Security: Prevent Shell Injection ---"
# ALWAYS use array arguments for commands when dealing with ANY untrusted input.
# This bypasses the shell and prevents malicious command concatenation.

# DANGER: AVOID THIS WITH USER INPUT
# user_input = "file_to_delete; echo PWNED >&2"
# `rm #{user_input}` # Executes 'rm file_to_delete' AND 'echo PWNED'!!
# system("rm #{user_input}") # Same risk

# SAFE: Use array arguments
puts "\nSafe delete attempt (will likely fail as 'file_to_delete;...' won't exist)"
user_input_safe = "file_to_delete; echo PWNED >&2"
begin
  system("rm", user_input_safe) # The shell is NOT invoked. 'rm' looks for a literal file named 'file_to_delete; echo PWNED >&2'
  puts "(system with array) Exit Status: #{$?.exitstatus}, Success: #{$?.success?}"
rescue => e
  puts "Error during safe delete: #{e.message}"
end

# Even safer/more robust with Open3 for output/error capture
begin
  stdout, stderr, status = Open3.capture3("rm", user_input_safe)
  puts "(Open3.capture3 with array) STDOUT: '#{stdout.chomp}', STDERR: '#{stderr.chomp}', Exit Status: #{status.exitstatus}, Success: #{status.success?}"
rescue => e
  puts "Error during Open3 safe delete: #{e.message}"
end

puts "\n--- 2. Implement Robust Error Handling ---"
# Never assume success. Always check exit status and stderr.

puts "\nExecuting a failing command (cat nonexistent.txt)"
stdout, stderr, status = Open3.capture3("cat", "nonexistent.txt")

if status.success?
  puts "Command succeeded.\nOutput: #{stdout}"
else
  puts "Command failed!\nExit Status: #{status.exitstatus}\nError: #{stderr.chomp}"
  # We can raise an error or log it for further action
  # raise "Command failed: #{stderr}" if status.exitstatus != 0
end

puts "\n--- 3. Optimize for Performance and Resource Management ---"
# Avoid frequent, short-lived external commands if Ruby can do the job directly.
# If commands are long-running, consider backgrounding (e.g., using '&' with system, or advanced Open3 with threads).

puts "Example: Reading file content"
# Bad practice: Shelling out for simple file reads
# content = `cat some_file.txt`

# Good practice: Ruby's built-in File class
begin
  File.write("sample.txt", "This is some sample content.")
  ruby_content = File.read("sample.txt")
  puts "Content read via Ruby: #{ruby_content.chomp}"
ensure
  File.delete("sample.txt") if File.exist?("sample.txt")
end

# For very high-frequency commands, consider if the design can be optimized.
# For example, if you're calling 'grep' thousands of times on the same file, 
# read the file once into Ruby and process it with Ruby's String/Array methods.

puts "\n--- 4. Choose the Right Tool for the Job ---"
puts "- Backticks: Simple output capture, trusted commands."
puts "- system(): Run command, check success/failure, secure with array args."
puts "- Open3: Granular control (stdin/out/err), complex interactions, secure with array args."

puts "\nArchitect your Ruby scripts with these principles to build robust, secure, and efficient systems."