This module defines all options that are used by parsers and/or converters as well as providing methods to deal with the options.
This sections contains all option definitions that are used by the included parsers/converters.
This sections contains all pre-defined option validators.
Ensures that the option value val for the option called name is a valid array. The parameter val can be
a comma separated string which is split into an array of values
or an array.
Additionally, the array is checked for the correct size.
# File lib/kramdown/options.rb, line 128 def self.simple_array_validator(val, name, size) if String === val val = val.split(/,/) elsif !(Array === val) raise Kramdown::Error, "Invalid type #{val.class} for option #{name}" end if val.size != size raise Kramdown::Error, "Option #{name} needs exactly #{size} values" end val end
This sections describes the methods that can be used on the Options module.
Allowed option types.
Struct class for storing the definition of an option.
Return a Hash with the default values for all options.
# File lib/kramdown/options.rb, line 69 def self.defaults temp = {} @options.each {|n, o| temp[o.name] = o.default} temp end
Define a new option called name (a Symbol) with the given type (String, Integer, Float, Symbol, Boolean, Object), default value default and the description desc. If a block is specified, it should validate the value and either raise an error or return a valid value.
The type 'Object' should only be used for complex types for which none of the other types suffices. A block needs to be specified when using type 'Object' and it has to cope with a value given as string and as the opaque type.
# File lib/kramdown/options.rb, line 49 def self.define(name, type, default, desc, &block) name = name.to_sym raise ArgumentError, "Option name #{name} is already used" if @options.has_key?(name) raise ArgumentError, "Invalid option type #{type} specified" if !ALLOWED_TYPES.include?(type) raise ArgumentError, "Invalid type for default value" if !(type === default) && !default.nil? raise ArgumentError, "Missing validator block" if type == Object && block.nil? @options[name] = Definition.new(name, type, default, desc, block) end
Return true if an option called name is defined.
# File lib/kramdown/options.rb, line 64 def self.defined?(name) @options.has_key?(name.to_sym) end
Return all option definitions.
# File lib/kramdown/options.rb, line 59 def self.definitions @options end
Merge the defaults Hash with the parsed options from the given Hash, i.e. only valid option names are considered and their value is run through the parse method.
# File lib/kramdown/options.rb, line 77 def self.merge(hash) temp = defaults hash.each do |k,v| k = k.to_sym next unless @options.has_key?(k) temp[k] = parse(k, v) end temp end
Parse the given value data as if it was a value for the option name and return the parsed value with the correct type.
If data already has the correct type, it is just returned. Otherwise it is converted to a String and then to the correct type.
# File lib/kramdown/options.rb, line 92 def self.parse(name, data) name = name.to_sym raise ArgumentError, "No option named #{name} defined" if !@options.has_key?(name) if !(@options[name].type === data) data = data.to_s data = if @options[name].type == String data elsif @options[name].type == Integer Integer(data) rescue raise Kramdown::Error, "Invalid integer value for option '#{name}': '#{data}'" elsif @options[name].type == Float Float(data) rescue raise Kramdown::Error, "Invalid float value for option '#{name}': '#{data}'" elsif @options[name].type == Symbol data.strip! data = data[1..-1] if data[0] == :: (data.empty? || data == 'nil' ? nil : data.to_sym) elsif @options[name].type == Boolean data.downcase.strip != 'false' && !data.empty? end end data = @options[name].validator[data] if @options[name].validator data end
Generated with the Darkfish Rdoc Generator 2.