常量文件的类vs模块

Question

I have a large number of constants: the average length of a domestic flight, the co2 emissions of different diet types, and co2/kwH conversions for different states, etc. I'd thought to put them in a separate file in my models and controllers, but wasn't quite sure what the best practice would be. Should this file be a class, a module, or neither? Should I place them in the models directory?

Examples:

class CalculatorConstants
  AVERAGE_DOMESTIC_FLIGHT_LENGTH = 1070
  class DietType
    def initialize(name, co2e)
      @name = name
      @co2e = co2e
    end
    attr_reader (:name, :co2e)
  end

  average_diet = DietType.new('average', 684.915)
  meaty = DietType.new('meaty', 867.964)
  no_beef = DietType.new('no beef', 450.585)
  pescatarian = DietType.new('pescatarian', 612.074)
  vegetarian = DietType.new('vegetarian', 420.482)
  vegan = DietType.new('vegan', 245.793)
  DIET_TYPES = [average_diet, meaty, no_beef, pescatarian, vegetarian, vegan]
end

or

module CalculatorConstants
  #Above Code
end

or neither? Where would be the best to put them?

Answer 1

I would prefer a module as namespace for the constants.

module CalculatorConstants
  AVERAGE_DOMESTIC_FLIGHT_LENGTH = 1070
  DietType = Struct.new(:name, :co2e)

  AVERAGE_DIET = DietType.new('average', 684.915)
  # ...
  DIET_TYPES = [AVERAGE_DIET]
end

p CalculatorConstants::DIET_TYPES

Answer 2

I usually use the config gem to manage constants. It is very easy to use: just store all constants to a YAML file, then these constants will be available in your app. For example,

# config/settings.yml
flight_length: 1070
diet_types:
  average: 684.915
  meaty: 867.964

You can access those constants in your app by

Settings.flight_length # => 1070
Settings.diet_types.average # => 684.915

Answer 3

I usually solve such problems by storing the constants in then yaml file, and then load them and access them through a hash.

example of the yaml file:

flight_length:
  domestic: 1070
  international: 3000
diet_types:
  - type1
  - type2
  - type3

Ruby code example:

#loading
constants = YAML.load_file(path)

#saving
File.open(path, 'w') { |f| YAML.dump(constants, f) }

#use
puts constants[:flight_length].inspect
# => { domestic: 1070, international: 3000 }

puts constants[:flight_length][:domestic]
# => 1070

puts constants[:diet_types].inspect
# => [type1, type2, type3]

It is nicely structured, it is independent from the ruby app, it can easily be edited outside the app context, it can be easily reused or converted, for example to json for use in javascript code.

You could wrap the methods for accessing the values in the yaml file, and various helper either as class methods of a class or instance methods, depending on your needs. If you will just load and save, then perhaps class methods are better. If you would have many helper methods, then instance methods are better. I would not go with a module.

Official yaml web site