class IniParse::Generator


max_trains = 500 ; More = slower
realistic_acceleration = true
road_side = left<br> ; Options for vehicles
end.to_ini
end
vehicle.option(“max_trains”, 500, :comment => “More = slower”)
vehicle.option(“realistic_acceleration”, true)
vehicle.option(“road_side”, “left”)
) do |vehicle|
:comment => “Options for vehicles”, :indent => “ ”
doc.section(“vehicle”,
IniParse.gen do |doc|
which belong to it.
adding a section, the same options will be inherited by all of the options
If you supply :indent, :comment_sep, or :comment_offset options when
Adds the supplied text to the beginning of the line.
:indent::
See String#ljust.
Indent the comment. Measured in characters from beginning of the line.
:comment_offset::
Adds an inline comment at the end of the line.
:comment::
each line type (except blanks) takes a number of optional parameters:
If you want to add slightly more complicated formatting to your document,
# => IniParse::Document
end
end
construction.autoslope = true
construction.build_on_slopes = true
doc.construction do |construction|
end
vehicle.max_trains = 500
vehicle.realistic_acceleration = true
vehicle.road_side = “left”
doc.vehicle do |vehicle|
IniParse.gen do |doc|
which comes with method_missing:
This can be simplified further if you don’t mind the small overhead
# => IniParse::Document
end
end
construction.option(“autoslope”, true)
construction.option(“build_on_slopes”, true)
doc.section(“construction”) do |construction|
end
vehicle.option(“max_trains”, 500)
vehicle.option(“realistic_acceleration”, true)
vehicle.option(“road_side”, “left”)
doc.section(“vehicle”) do |vehicle|
IniParse.gen do |doc|
The Generator is exposed through IniParse.gen.
which will handle it all for you.
Document, Section and Option instances, it is preferable to use Generator
Rather than trying to hack together new INI documents by manually creating
Generator provides a means for easily creating new INI documents.

def self.gen(opts = {}, &blk)


IniParse::Document
==== Returns

Creates a new IniParse::Document with the given sections and options. 
def self.gen(opts = {}, &blk)
  new(opts).gen(&blk)
end

def blank

Adds a new blank line to the document. 
def blank
  @context.lines << Lines::Blank.new
end

def comment(comment, opts = {})


comment:: The text for the comment line.
==== Parameters

Adds a new comment line to the document. 
def comment(comment, opts = {})
  @context.lines << Lines::Comment.new(
    line_options(opts.merge(:comment => comment))
  )
end

def gen # :nodoc:

:nodoc: 
def gen # :nodoc:
  yield self
  @document
end

def initialize(opts = {}) # :nodoc:

:nodoc: 
def initialize(opts = {}) # :nodoc:
  @document   = IniParse::Document.new
  @context    = @document
  @in_section = false
  @opt_stack  = [opts]
end

def line_options(given_opts) # :nodoc:

:nodoc:

rather than the global defaults.
If the context is a section, we use the section options as a base,

Returns options for a line. 
def line_options(given_opts) # :nodoc:
  @opt_stack.last.empty? ? given_opts : @opt_stack.last.merge(given_opts)
end

def method_missing(name, *args, &blk) # :nodoc:

:nodoc: 
def method_missing(name, *args, &blk) # :nodoc:
  if m = name.to_s.match(/(.*)=$/)
    option(m[1], *args)
  else
    section(name.to_s, *args, &blk)
  end
end

def option(key, value, opts = {})


If no section has been added to the document yet.
IniParse::NoSectionError::
==== Raises

opts:: Extra options for the line (formatting, etc).
value:: The option's value.
key:: The key (name) for this option.
==== Parameters

section has been added to the document.
Can only be called as part of a section block, or after at least one

Adds a new option to the current section. 
def option(key, value, opts = {})
  @context.lines << Lines::Option.new(
    key, value, line_options(opts)
  )
rescue LineNotAllowed
  # Tried to add an Option to a Document.
  raise NoSectionError,
    'Your INI document contains an option before the first section is ' \
    'declared which is not allowed.'
end

def section(name, opts = {})


name:: A name for the given section.
==== Parameters

Generator#gen) in order to add options to the section.
You can optionally supply a block (as detailed in the documentation for

Creates a new section with the given name and adds it to the document. 
def section(name, opts = {})
  if @in_section
    # Nesting sections is bad, mmmkay?
    raise LineNotAllowed, "You can't nest sections in INI files."
  end
  # Add to a section if it already exists
  if @document.has_section?(name.to_s())
    @context = @document[name.to_s()]
  else
    @context = Lines::Section.new(name, line_options(opts))
    @document.lines << @context
  end
  if block_given?
    begin
      @in_section = true
      with_options(opts) { yield self }
      @context = @document
      blank()
    ensure
      @in_section = false
    end
  end
end

def with_options(opts = {}) # :nodoc:

:nodoc:
Wraps lines, setting default options for each. 
def with_options(opts = {}) # :nodoc:
  opts = opts.dup
  opts.delete(:comment)
  @opt_stack.push( @opt_stack.last.merge(opts))
  yield self
  @opt_stack.pop
end