This module defines all options that are used by parsers and/or converters as well as providing methods to deal with the options.
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 136 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
Ensures that the option value val
for the option called
name
is a valid hash. The parameter val
can be
a hash in YAML format
or a Ruby Hash object.
# File lib/kramdown/options.rb, line 153 def self.simple_hash_validator(val, name) if String === val begin val = YAML.load(val) rescue RuntimeError, ArgumentError, SyntaxError raise Kramdown::Error, "Invalid YAML value for option #{name}" end end raise Kramdown::Error, "Invalid type #{val.class} for option #{name}" if !(Hash === val) val end
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 @options.has_key?(k) ? temp[k] = parse(k, v) : temp[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 91 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 str_to_sym(data) elsif @options[name].type == Boolean data.downcase.strip != 'false' && !data.empty? end end data = @options[name].validator[data] if @options[name].validator data end
Converts the given String data
into a Symbol or
nil
with the following provisions:
A leading colon is stripped from the string.
An empty value or a value equal to “nil” results in nil
.
# File lib/kramdown/options.rb, line 117 def self.str_to_sym(data) data = data.strip data = data[1..-1] if data[0] == : (data.empty? || data == 'nil' ? nil : data.to_sym) end