How to use global variables in Ruby

tmp_dir is defined as a variable in the class definition, but in the instance function you're looking for a tmp_dir defined on an instance of the class. That's why tmp_dir is undefined inside the function.

You can make it global or make it a class variable as quick fixes. I think there's a better alternative: wrap this up in its own class that knows how to cache, and then initialize tmp_dir without making it global OR a class variable:

class Cacher
    def initialize(tmp_dir)
        @tmp_dir = tmp_dir
    end

    def cache(page)
        wget "#{@tmp_dir}/page"
    end
end

# in your main file:
cacher = Cacher.new('/path/to/tmp/dir') # here's your configuration line, but with no global!

# later

cacher.cache("index.html")

You're correct. You need to make the variable global by prefixing it with $. Ex:

$tmp_dir = '/path/to/tmp/dir'

Rather than do that, you could also make it an instance variable, or you could refactor to make it a class. I would recommend doing what Riley Lark said.

You are right. Global variables should be avoided. The natural choices are instance variables on the class, or constants.

In your case, it looks like you have something that does not change throughout the execution of the script. Then, a constant is most appropriate. You can define this constant within an appropriate module.

TmpDir = "/path/to/tmp/dir"

Also notice that Ruby has a built in way to refer to tmp dir.

require "tmpdir"
Dir.tmpdir # => "/tmp" (depending on the environment)

In addition to other answers, to make local variable set in class definition scope work in method definition, you can use define_method which is a method that takes block. Blocks in Ruby are closures, so they go together with environment that they were set in:

define_method(:cache) do |page|
  begin
    %x[wget -q -O #{tmp_dir}/page #{page}]
  rescue => msg
    puts "error: #{msg}"
    exit
  end
end

Short answer

It sounds like you're writing a short script. If that's the case, there's no reason you can't use a modifiable global variable like $tmp_dir. But if you don't need to modify it, you should use @sawa's solution of a global constant like TMP_DIR. In that case you should call .freeze on the string to avoid accidental modification.

Longer answer

If the script becomes longer or more complex, you should refactor into classes. The TMP_DIR solution will still work in this case. But if you need to modify the value, you can create a ConfigObject class to group these variables.

Example:

ConfigObject = Struct.new(:tmp_dir, :file_limit)
# it's a good idea to create this before everything else
$config = ConfigObject.new('/tmp/dir', 10)

class Foo
  def do_something
    $config.file_limit  # use this somehow
    $config.file_limit = 5  # change
  end
end

A similar technique uses class variables to accomplish the same thing:

class ConfigObject
  class << self
    attr_accessor :tmp_dir, :file_limit
  end
  @tmp_dir = '/tmp/dir'
  @file_limit = 10
end

class Foo
  def do_something
    ConfigObject.file_limit  # use this somehow
    ConfigObject.file_limit = 5  # change
  end
end

Think of ConfigObject as a "service" used by other classes. If your app gets complicated enough to need multiple interacting services, you might need want to set up a kind of service registry that hold references to the services (google "dependency injection" for more info).

Note: you shouldn't name your class Config because that's already a built-in class.