class Rtpl

# File lib/rtpl.rb, line 11
def initialize(template)
  @ast                   = Rtpl::Parser.new.parse(template)
  @vars                  = {}
  @parsed_blocks         = {}
  @parsed_blocks.default = ""
  @transform             = Rtpl::Transform.new
  @sub_blocks            = false
end

# File lib/rtpl.rb, line 20
def assign(key, value)
  @vars[key] = value
end

# File lib/rtpl.rb, line 37
def out(key = "main")
  @parsed_blocks[key].to_s
end

# File lib/rtpl.rb, line 24
def parse(block_name)
  if block_name =~ /\./
    @sub_blocks = true
    @parsed_blocks[block_name] +=
      nested_output(@transform.apply(sub_block(block_name), :vars => @vars),
                    block_name)
  else
    @parsed_blocks[block_name] +=
      block_output(@transform.apply(@ast, :vars => @vars).
                   detect{|b| b[:open][:name] == block_name })
  end
end

# File lib/rtpl.rb, line 43
def block_output(block)
  raise ArgumentError if (block.nil? || block.empty?)
  return block[:content].join unless @sub_blocks

  before      = block[:content].detect {|h| h.has_key?(:before) }
  after       = block[:content].detect {|h| h.has_key?(:after) }
  inner_block = block[:content].detect {|h| h.has_key?(:open) }
  before      = before ? before[:before].join : ""
  after       = after ? after[:after].join : ""
  key         = block[:open][:name].to_s + "." + inner_block[:open][:name]
  inner_block = @parsed_blocks[key]

  #clear the inner block when parsing a parent block
  @parsed_blocks[key] = ""
  before.to_s + inner_block + after.to_s
end

# File lib/rtpl.rb, line 60
def nested_output(block, block_name)
  nested_block =
    block[:content].
    detect {|b| !b.instance_of?(String) && b.has_key?(:open)}
  if nested_block.nil?
    output = block[:content].join if block[:content]
  else
    before      = block[:content].detect {|h| h.has_key?(:before) }
    after       = block[:content].detect {|h| h.has_key?(:after) }
    before      = before ? before[:before].join : ""
    after       = after ? after[:after].join : ""
    output =
      before +
      @parsed_blocks["#{block_name}.#{nested_block[:open][:name]}"] +
      after

    # clear the key when parsing a parent block
    @parsed_blocks["#{block_name}.#{nested_block[:open][:name]}"] = ""
  end

  output
end

# File lib/rtpl.rb, line 83
def sub_block(block_name)
  name_parts  = block_name.split(".")
  block       = nil
  tree        = @transform.apply(@ast, :vars => @vars)

  name_parts.each do |n|
    if block
      before = block.detect {|b| b.has_key?(:before) }
      after  = block.detect {|b| b.has_key?(:after) }
      old_block = block
      block =
        if n == name_parts.last
          block.detect {|b| b.has_key?(:open) && b[:open][:name] == n }
        else
          block.
            detect {|b| b.has_key?(:open) && b[:open][:name] == n }[:content]
        end

      raise ArgumentError, "Could not find #{block_name}" if block.nil?

      unless block.instance_of?(Array)
        block.merge!(before) if before
        block.merge!(after) if after
      end
    else
      block =
        tree.detect {|b| (b[:open] != "" && b[:open][:name]) == n }[:content]
    end
  end

  block
end